src/components/gcm_driver/fake_gcm_client.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/gcm_driver/fake_gcm_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/sequenced_task_runner.h"
  11 #include "base/sys_byteorder.h"
  12 #include "base/time/time.h"
  13 #include "google_apis/gcm/base/encryptor.h"
  14 #include "net/base/ip_endpoint.h"
  15
  16 namespace gcm {
  17
  18 FakeGCMClient::FakeGCMClient(
  19     StartMode start_mode,
  20     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
  21     const scoped_refptr<base::SequencedTaskRunner>& io_thread)
  22     : delegate_(NULL),
  23       status_(UNINITIALIZED),
  24       start_mode_(start_mode),
  25       ui_thread_(ui_thread),
  26       io_thread_(io_thread),
  27       weak_ptr_factory_(this) {
  28 }
  29
  30 FakeGCMClient::~FakeGCMClient() {
  31 }
  32
  33 void FakeGCMClient::Initialize(
  34     const ChromeBuildInfo& chrome_build_info,
  35     const base::FilePath& store_path,
  36     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
  37     const scoped_refptr<net::URLRequestContextGetter>&
  38         url_request_context_getter,
  39     scoped_ptr<Encryptor> encryptor,
  40     Delegate* delegate) {
  41   delegate_ = delegate;
  42 }
  43
  44 void FakeGCMClient::Start() {
  45   DCHECK(io_thread_->RunsTasksOnCurrentThread());
  46   DCHECK_NE(STARTED, status_);
  47
  48   if (start_mode_ == DELAY_START)
  49     return;
  50   DoLoading();
  51 }
  52
  53 void FakeGCMClient::DoLoading() {
  54   status_ = STARTED;
  55   base::MessageLoop::current()->PostTask(
  56       FROM_HERE,
  57       base::Bind(&FakeGCMClient::CheckinFinished,
  58                  weak_ptr_factory_.GetWeakPtr()));
  59 }
  60
  61 void FakeGCMClient::Stop() {
  62   DCHECK(io_thread_->RunsTasksOnCurrentThread());
  63   status_ = STOPPED;
  64   delegate_->OnDisconnected();
  65 }
  66
  67 void FakeGCMClient::CheckOut() {
  68   DCHECK(io_thread_->RunsTasksOnCurrentThread());
  69   status_ = CHECKED_OUT;
  70 }
  71
  72 void FakeGCMClient::Register(const std::string& app_id,
  73                              const std::vector<std::string>& sender_ids) {
  74   DCHECK(io_thread_->RunsTasksOnCurrentThread());
  75
  76   std::string registration_id = GetRegistrationIdFromSenderIds(sender_ids);
  77   base::MessageLoop::current()->PostTask(
  78       FROM_HERE,
  79       base::Bind(&FakeGCMClient::RegisterFinished,
  80                  weak_ptr_factory_.GetWeakPtr(),
  81                  app_id,
  82                  registration_id));
  83 }
  84
  85 void FakeGCMClient::Unregister(const std::string& app_id) {
  86   DCHECK(io_thread_->RunsTasksOnCurrentThread());
  87
  88   base::MessageLoop::current()->PostTask(
  89       FROM_HERE,
  90       base::Bind(&FakeGCMClient::UnregisterFinished,
  91                  weak_ptr_factory_.GetWeakPtr(),
  92                  app_id));
  93 }
  94
  95 void FakeGCMClient::Send(const std::string& app_id,
  96                          const std::string& receiver_id,
  97                          const OutgoingMessage& message) {
  98   DCHECK(io_thread_->RunsTasksOnCurrentThread());
  99
 100   base::MessageLoop::current()->PostTask(
 101       FROM_HERE,
 102       base::Bind(&FakeGCMClient::SendFinished,
 103                  weak_ptr_factory_.GetWeakPtr(),
 104                  app_id,
 105                  message));
 106 }
 107
 108 void FakeGCMClient::SetRecording(bool recording) {
 109 }
 110
 111 void FakeGCMClient::ClearActivityLogs() {
 112 }
 113
 114 GCMClient::GCMStatistics FakeGCMClient::GetStatistics() const {
 115   return GCMClient::GCMStatistics();
 116 }
 117
 118 void FakeGCMClient::SetAccountsForCheckin(
 119     const std::map<std::string, std::string>& account_tokens) {
 120 }
 121
 122 void FakeGCMClient::PerformDelayedLoading() {
 123   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 124
 125   io_thread_->PostTask(
 126       FROM_HERE,
 127       base::Bind(&FakeGCMClient::DoLoading, weak_ptr_factory_.GetWeakPtr()));
 128 }
 129
 130 void FakeGCMClient::ReceiveMessage(const std::string& app_id,
 131                                    const IncomingMessage& message) {
 132   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 133
 134   io_thread_->PostTask(
 135       FROM_HERE,
 136       base::Bind(&FakeGCMClient::MessageReceived,
 137                  weak_ptr_factory_.GetWeakPtr(),
 138                  app_id,
 139                  message));
 140 }
 141
 142 void FakeGCMClient::DeleteMessages(const std::string& app_id) {
 143   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 144
 145   io_thread_->PostTask(
 146       FROM_HERE,
 147       base::Bind(&FakeGCMClient::MessagesDeleted,
 148                  weak_ptr_factory_.GetWeakPtr(),
 149                  app_id));
 150 }
 151
 152 // static
 153 std::string FakeGCMClient::GetRegistrationIdFromSenderIds(
 154     const std::vector<std::string>& sender_ids) {
 155   // GCMService normalizes the sender IDs by making them sorted.
 156   std::vector<std::string> normalized_sender_ids = sender_ids;
 157   std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
 158
 159   // Simulate the registration_id by concaternating all sender IDs.
 160   // Set registration_id to empty to denote an error if sender_ids contains a
 161   // hint.
 162   std::string registration_id;
 163   if (sender_ids.size() != 1 ||
 164       sender_ids[0].find("error") == std::string::npos) {
 165     for (size_t i = 0; i < normalized_sender_ids.size(); ++i) {
 166       if (i > 0)
 167         registration_id += ",";
 168       registration_id += normalized_sender_ids[i];
 169     }
 170   }
 171   return registration_id;
 172 }
 173
 174 void FakeGCMClient::CheckinFinished() {
 175   delegate_->OnGCMReady();
 176   delegate_->OnConnected(net::IPEndPoint());
 177 }
 178
 179 void FakeGCMClient::RegisterFinished(const std::string& app_id,
 180                                      const std::string& registrion_id) {
 181   delegate_->OnRegisterFinished(
 182       app_id, registrion_id, registrion_id.empty() ? SERVER_ERROR : SUCCESS);
 183 }
 184
 185 void FakeGCMClient::UnregisterFinished(const std::string& app_id) {
 186   delegate_->OnUnregisterFinished(app_id, GCMClient::SUCCESS);
 187 }
 188
 189 void FakeGCMClient::SendFinished(const std::string& app_id,
 190                                  const OutgoingMessage& message) {
 191   delegate_->OnSendFinished(app_id, message.id, SUCCESS);
 192
 193   // Simulate send error if message id contains a hint.
 194   if (message.id.find("error") != std::string::npos) {
 195     SendErrorDetails send_error_details;
 196     send_error_details.message_id = message.id;
 197     send_error_details.result = NETWORK_ERROR;
 198     send_error_details.additional_data = message.data;
 199     base::MessageLoop::current()->PostDelayedTask(
 200         FROM_HERE,
 201         base::Bind(&FakeGCMClient::MessageSendError,
 202                    weak_ptr_factory_.GetWeakPtr(),
 203                    app_id,
 204                    send_error_details),
 205         base::TimeDelta::FromMilliseconds(200));
 206   } else if(message.id.find("ack") != std::string::npos) {
 207     base::MessageLoop::current()->PostDelayedTask(
 208         FROM_HERE,
 209         base::Bind(&FakeGCMClient::SendAcknowledgement,
 210                    weak_ptr_factory_.GetWeakPtr(),
 211                    app_id,
 212                    message.id),
 213         base::TimeDelta::FromMilliseconds(200));
 214
 215   }
 216 }
 217
 218 void FakeGCMClient::MessageReceived(const std::string& app_id,
 219                                     const IncomingMessage& message) {
 220   if (delegate_)
 221     delegate_->OnMessageReceived(app_id, message);
 222 }
 223
 224 void FakeGCMClient::MessagesDeleted(const std::string& app_id) {
 225   if (delegate_)
 226     delegate_->OnMessagesDeleted(app_id);
 227 }
 228
 229 void FakeGCMClient::MessageSendError(
 230     const std::string& app_id,
 231     const GCMClient::SendErrorDetails& send_error_details) {
 232   if (delegate_)
 233     delegate_->OnMessageSendError(app_id, send_error_details);
 234 }
 235
 236 void FakeGCMClient::SendAcknowledgement(const std::string& app_id,
 237                                         const std::string& message_id) {
 238   if (delegate_)
 239     delegate_->OnSendAcknowledged(app_id, message_id);
 240 }
 241
 242 }  // namespace gcm