chrome/browser/services/gcm/gcm_client_mock.cc

   1 // Copyright 2013 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 "chrome/browser/services/gcm/gcm_client_mock.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/sys_byteorder.h"
  11 #include "base/time/time.h"
  12 #include "content/public/browser/browser_thread.h"
  13
  14 namespace gcm {
  15
  16 namespace {
  17
  18 // Converts the 8-byte prefix of a string into a uint64 value.
  19 uint64 HashToUInt64(const std::string& hash) {
  20   uint64 value;
  21   DCHECK_GE(hash.size(), sizeof(value));
  22   memcpy(&value, hash.data(), sizeof(value));
  23   return base::HostToNet64(value);
  24 }
  25
  26 }  // namespace
  27
  28 GCMClientMock::GCMClientMock()
  29     : is_loading_(false),
  30       simulate_server_error_(false) {
  31 }
  32
  33 GCMClientMock::~GCMClientMock() {
  34 }
  35
  36 void GCMClientMock::SetUserDelegate(const std::string& username,
  37                                     Delegate* delegate) {
  38   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
  39
  40   if (delegate)
  41     delegates_[username] = delegate;
  42   else
  43     delegates_.erase(username);
  44 }
  45
  46 void GCMClientMock::CheckIn(const std::string& username) {
  47   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
  48
  49   // Simulate the android_id and secret by some sort of hashing.
  50   CheckinInfo checkin_info;
  51   if (!simulate_server_error_)
  52     checkin_info = GetCheckinInfoFromUsername(username);
  53
  54   base::MessageLoop::current()->PostTask(
  55       FROM_HERE,
  56       base::Bind(&GCMClientMock::CheckInFinished,
  57                  base::Unretained(this),
  58                  username,
  59                  checkin_info));
  60 }
  61
  62 void GCMClientMock::Register(const std::string& username,
  63                              const std::string& app_id,
  64                              const std::string& cert,
  65                              const std::vector<std::string>& sender_ids) {
  66   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
  67
  68   std::string registration_id;
  69   if (!simulate_server_error_)
  70     registration_id = GetRegistrationIdFromSenderIds(sender_ids);
  71
  72   base::MessageLoop::current()->PostTask(
  73       FROM_HERE,
  74       base::Bind(&GCMClientMock::RegisterFinished,
  75                  base::Unretained(this),
  76                  username,
  77                  app_id,
  78                  registration_id));
  79 }
  80
  81 void GCMClientMock::Unregister(const std::string& username,
  82                                const std::string& app_id) {
  83 }
  84
  85 void GCMClientMock::Send(const std::string& username,
  86                          const std::string& app_id,
  87                          const std::string& receiver_id,
  88                          const OutgoingMessage& message) {
  89   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
  90
  91   base::MessageLoop::current()->PostTask(
  92       FROM_HERE,
  93       base::Bind(&GCMClientMock::SendFinished,
  94                  base::Unretained(this),
  95                  username,
  96                  app_id,
  97                  message.id));
  98 }
  99
 100 bool GCMClientMock::IsLoading() const {
 101   return is_loading_;
 102 }
 103
 104 void GCMClientMock::ReceiveMessage(const std::string& username,
 105                                    const std::string& app_id,
 106                                    const IncomingMessage& message) {
 107   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 108
 109   content::BrowserThread::PostTask(
 110       content::BrowserThread::IO,
 111       FROM_HERE,
 112       base::Bind(&GCMClientMock::MessageReceived,
 113                  base::Unretained(this),
 114                  username,
 115                  app_id,
 116                  message));
 117 }
 118
 119 void GCMClientMock::DeleteMessages(const std::string& username,
 120                                    const std::string& app_id) {
 121   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 122
 123   content::BrowserThread::PostTask(
 124       content::BrowserThread::IO,
 125       FROM_HERE,
 126       base::Bind(&GCMClientMock::MessagesDeleted,
 127                  base::Unretained(this),
 128                  username,
 129                  app_id));
 130 }
 131
 132 void GCMClientMock::SetIsLoading(bool is_loading) {
 133   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 134
 135   if (is_loading == is_loading_)
 136     return;
 137   is_loading_ = is_loading;
 138
 139   if (is_loading_)
 140     return;
 141   content::BrowserThread::PostTask(
 142       content::BrowserThread::IO,
 143       FROM_HERE,
 144       base::Bind(&GCMClientMock::LoadingCompleted,
 145                  base::Unretained(this)));
 146 }
 147
 148 // static
 149 GCMClient::CheckinInfo GCMClientMock::GetCheckinInfoFromUsername(
 150     const std::string& username) {
 151   CheckinInfo checkin_info;
 152   checkin_info.android_id = HashToUInt64(username);
 153   checkin_info.secret = checkin_info.android_id / 10;
 154   return checkin_info;
 155 }
 156
 157 // static
 158 std::string GCMClientMock::GetRegistrationIdFromSenderIds(
 159     const std::vector<std::string>& sender_ids) {
 160   // Simulate the registration_id by concaternating all sender IDs.
 161   // Set registration_id to empty to denote an error if sender_ids contains a
 162   // hint.
 163   std::string registration_id;
 164   if (sender_ids.size() != 1 ||
 165       sender_ids[0].find("error") == std::string::npos) {
 166     for (size_t i = 0; i < sender_ids.size(); ++i) {
 167       if (i > 0)
 168         registration_id += ",";
 169       registration_id += sender_ids[i];
 170     }
 171   }
 172   return registration_id;
 173 }
 174
 175 GCMClient::Delegate* GCMClientMock::GetDelegate(
 176     const std::string& username) const {
 177   std::map<std::string, Delegate*>::const_iterator iter =
 178       delegates_.find(username);
 179   DCHECK(iter != delegates_.end());
 180   return iter->second;
 181 }
 182
 183 void GCMClientMock::CheckInFinished(std::string username,
 184                                     CheckinInfo checkin_info) {
 185   GetDelegate(username)->OnCheckInFinished(
 186       checkin_info, checkin_info.IsValid() ? SUCCESS : SERVER_ERROR);
 187 }
 188
 189 void GCMClientMock::RegisterFinished(std::string username,
 190                                      std::string app_id,
 191                                      std::string registrion_id) {
 192   GetDelegate(username)->OnRegisterFinished(
 193       app_id, registrion_id, registrion_id.empty() ? SERVER_ERROR : SUCCESS);
 194 }
 195
 196 void GCMClientMock::SendFinished(std::string username,
 197                                  std::string app_id,
 198                                  std::string message_id) {
 199   GetDelegate(username)->OnSendFinished(app_id, message_id, SUCCESS);
 200
 201   // Simulate send error if message id contains a hint.
 202   if (message_id.find("error") != std::string::npos) {
 203     base::MessageLoop::current()->PostDelayedTask(
 204         FROM_HERE,
 205         base::Bind(&GCMClientMock::MessageSendError,
 206                    base::Unretained(this),
 207                    username,
 208                    app_id,
 209                    message_id),
 210         base::TimeDelta::FromMilliseconds(200));
 211   }
 212 }
 213
 214 void GCMClientMock::MessageReceived(std::string username,
 215                                     std::string app_id,
 216                                     IncomingMessage message) {
 217   GetDelegate(username)->OnMessageReceived(app_id, message);
 218 }
 219
 220 void GCMClientMock::MessagesDeleted(std::string username, std::string app_id) {
 221   GetDelegate(username)->OnMessagesDeleted(app_id);
 222 }
 223
 224 void GCMClientMock::MessageSendError(std::string username,
 225                                      std::string app_id,
 226                                      std::string message_id) {
 227   GetDelegate(username)->OnMessageSendError(app_id, message_id, NETWORK_ERROR);
 228 }
 229
 230 void GCMClientMock::LoadingCompleted() {
 231   for (std::map<std::string, Delegate*>::const_iterator iter =
 232            delegates_.begin();
 233        iter != delegates_.end(); ++iter) {
 234     iter->second->OnLoadingCompleted();
 235   }
 236 }
 237
 238 }  // namespace gcm