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::UpdateAccountMapping(
 123     const AccountMapping& account_mapping) {
 124 }
 125
 126 void FakeGCMClient::RemoveAccountMapping(const std::string& account_id) {
 127 }
 128
 129 void FakeGCMClient::PerformDelayedLoading() {
 130   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 131
 132   io_thread_->PostTask(
 133       FROM_HERE,
 134       base::Bind(&FakeGCMClient::DoLoading, weak_ptr_factory_.GetWeakPtr()));
 135 }
 136
 137 void FakeGCMClient::ReceiveMessage(const std::string& app_id,
 138                                    const IncomingMessage& message) {
 139   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 140
 141   io_thread_->PostTask(
 142       FROM_HERE,
 143       base::Bind(&FakeGCMClient::MessageReceived,
 144                  weak_ptr_factory_.GetWeakPtr(),
 145                  app_id,
 146                  message));
 147 }
 148
 149 void FakeGCMClient::DeleteMessages(const std::string& app_id) {
 150   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 151
 152   io_thread_->PostTask(
 153       FROM_HERE,
 154       base::Bind(&FakeGCMClient::MessagesDeleted,
 155                  weak_ptr_factory_.GetWeakPtr(),
 156                  app_id));
 157 }
 158
 159 // static
 160 std::string FakeGCMClient::GetRegistrationIdFromSenderIds(
 161     const std::vector<std::string>& sender_ids) {
 162   // GCMService normalizes the sender IDs by making them sorted.
 163   std::vector<std::string> normalized_sender_ids = sender_ids;
 164   std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
 165
 166   // Simulate the registration_id by concaternating all sender IDs.
 167   // Set registration_id to empty to denote an error if sender_ids contains a
 168   // hint.
 169   std::string registration_id;
 170   if (sender_ids.size() != 1 ||
 171       sender_ids[0].find("error") == std::string::npos) {
 172     for (size_t i = 0; i < normalized_sender_ids.size(); ++i) {
 173       if (i > 0)
 174         registration_id += ",";
 175       registration_id += normalized_sender_ids[i];
 176     }
 177   }
 178   return registration_id;
 179 }
 180
 181 void FakeGCMClient::CheckinFinished() {
 182   delegate_->OnGCMReady();
 183   delegate_->OnConnected(net::IPEndPoint());
 184 }
 185
 186 void FakeGCMClient::RegisterFinished(const std::string& app_id,
 187                                      const std::string& registrion_id) {
 188   delegate_->OnRegisterFinished(
 189       app_id, registrion_id, registrion_id.empty() ? SERVER_ERROR : SUCCESS);
 190 }
 191
 192 void FakeGCMClient::UnregisterFinished(const std::string& app_id) {
 193   delegate_->OnUnregisterFinished(app_id, GCMClient::SUCCESS);
 194 }
 195
 196 void FakeGCMClient::SendFinished(const std::string& app_id,
 197                                  const OutgoingMessage& message) {
 198   delegate_->OnSendFinished(app_id, message.id, SUCCESS);
 199
 200   // Simulate send error if message id contains a hint.
 201   if (message.id.find("error") != std::string::npos) {
 202     SendErrorDetails send_error_details;
 203     send_error_details.message_id = message.id;
 204     send_error_details.result = NETWORK_ERROR;
 205     send_error_details.additional_data = message.data;
 206     base::MessageLoop::current()->PostDelayedTask(
 207         FROM_HERE,
 208         base::Bind(&FakeGCMClient::MessageSendError,
 209                    weak_ptr_factory_.GetWeakPtr(),
 210                    app_id,
 211                    send_error_details),
 212         base::TimeDelta::FromMilliseconds(200));
 213   } else if(message.id.find("ack") != std::string::npos) {
 214     base::MessageLoop::current()->PostDelayedTask(
 215         FROM_HERE,
 216         base::Bind(&FakeGCMClient::SendAcknowledgement,
 217                    weak_ptr_factory_.GetWeakPtr(),
 218                    app_id,
 219                    message.id),
 220         base::TimeDelta::FromMilliseconds(200));
 221
 222   }
 223 }
 224
 225 void FakeGCMClient::MessageReceived(const std::string& app_id,
 226                                     const IncomingMessage& message) {
 227   if (delegate_)
 228     delegate_->OnMessageReceived(app_id, message);
 229 }
 230
 231 void FakeGCMClient::MessagesDeleted(const std::string& app_id) {
 232   if (delegate_)
 233     delegate_->OnMessagesDeleted(app_id);
 234 }
 235
 236 void FakeGCMClient::MessageSendError(
 237     const std::string& app_id,
 238     const GCMClient::SendErrorDetails& send_error_details) {
 239   if (delegate_)
 240     delegate_->OnMessageSendError(app_id, send_error_details);
 241 }
 242
 243 void FakeGCMClient::SendAcknowledgement(const std::string& app_id,
 244                                         const std::string& message_id) {
 245   if (delegate_)
 246     delegate_->OnSendAcknowledged(app_id, message_id);
 247 }
 248
 249 }  // namespace gcm