components/invalidation/sync_system_resources.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/invalidation/sync_system_resources.h"
   6
   7 #include <cstdlib>
   8 #include <cstring>
   9 #include <string>
  10
  11 #include "base/bind.h"
  12 #include "base/logging.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "components/invalidation/gcm_network_channel.h"
  18 #include "components/invalidation/gcm_network_channel_delegate.h"
  19 #include "components/invalidation/invalidation_util.h"
  20 #include "components/invalidation/push_client_channel.h"
  21 #include "google/cacheinvalidation/deps/callback.h"
  22 #include "google/cacheinvalidation/include/types.h"
  23 #include "jingle/notifier/listener/push_client.h"
  24
  25 namespace syncer {
  26
  27 SyncLogger::SyncLogger() {}
  28 SyncLogger::~SyncLogger() {}
  29
  30 void SyncLogger::Log(LogLevel level, const char* file, int line,
  31                      const char* format, ...) {
  32   logging::LogSeverity log_severity = -2;  // VLOG(2)
  33   bool emit_log = false;
  34   switch (level) {
  35     case FINE_LEVEL:
  36       log_severity = -2;  // VLOG(2)
  37       emit_log = VLOG_IS_ON(2);
  38       break;
  39     case INFO_LEVEL:
  40       log_severity = -1;  // VLOG(1)
  41       emit_log = VLOG_IS_ON(1);
  42       break;
  43     case WARNING_LEVEL:
  44       log_severity = logging::LOG_WARNING;
  45       emit_log = LOG_IS_ON(WARNING);
  46       break;
  47     case SEVERE_LEVEL:
  48       log_severity = logging::LOG_ERROR;
  49       emit_log = LOG_IS_ON(ERROR);
  50       break;
  51   }
  52   if (emit_log) {
  53     va_list ap;
  54     va_start(ap, format);
  55     std::string result;
  56     base::StringAppendV(&result, format, ap);
  57     logging::LogMessage(file, line, log_severity).stream() << result;
  58     va_end(ap);
  59   }
  60 }
  61
  62 void SyncLogger::SetSystemResources(invalidation::SystemResources* resources) {
  63   // Do nothing.
  64 }
  65
  66 SyncInvalidationScheduler::SyncInvalidationScheduler()
  67     : created_on_loop_(base::MessageLoop::current()),
  68       is_started_(false),
  69       is_stopped_(false),
  70       weak_factory_(this) {
  71   CHECK(created_on_loop_);
  72 }
  73
  74 SyncInvalidationScheduler::~SyncInvalidationScheduler() {
  75   CHECK_EQ(created_on_loop_, base::MessageLoop::current());
  76   CHECK(is_stopped_);
  77 }
  78
  79 void SyncInvalidationScheduler::Start() {
  80   CHECK_EQ(created_on_loop_, base::MessageLoop::current());
  81   CHECK(!is_started_);
  82   is_started_ = true;
  83   is_stopped_ = false;
  84   weak_factory_.InvalidateWeakPtrs();
  85 }
  86
  87 void SyncInvalidationScheduler::Stop() {
  88   CHECK_EQ(created_on_loop_, base::MessageLoop::current());
  89   is_stopped_ = true;
  90   is_started_ = false;
  91   weak_factory_.InvalidateWeakPtrs();
  92   STLDeleteElements(&posted_tasks_);
  93 }
  94
  95 void SyncInvalidationScheduler::Schedule(invalidation::TimeDelta delay,
  96                                          invalidation::Closure* task) {
  97   DCHECK(invalidation::IsCallbackRepeatable(task));
  98   CHECK_EQ(created_on_loop_, base::MessageLoop::current());
  99
 100   if (!is_started_) {
 101     delete task;
 102     return;
 103   }
 104
 105   posted_tasks_.insert(task);
 106   base::MessageLoop::current()->PostDelayedTask(
 107       FROM_HERE, base::Bind(&SyncInvalidationScheduler::RunPostedTask,
 108                             weak_factory_.GetWeakPtr(), task),
 109       delay);
 110 }
 111
 112 bool SyncInvalidationScheduler::IsRunningOnThread() const {
 113   return created_on_loop_ == base::MessageLoop::current();
 114 }
 115
 116 invalidation::Time SyncInvalidationScheduler::GetCurrentTime() const {
 117   CHECK_EQ(created_on_loop_, base::MessageLoop::current());
 118   return base::Time::Now();
 119 }
 120
 121 void SyncInvalidationScheduler::SetSystemResources(
 122     invalidation::SystemResources* resources) {
 123   // Do nothing.
 124 }
 125
 126 void SyncInvalidationScheduler::RunPostedTask(invalidation::Closure* task) {
 127   CHECK_EQ(created_on_loop_, base::MessageLoop::current());
 128   task->Run();
 129   posted_tasks_.erase(task);
 130   delete task;
 131 }
 132
 133 SyncNetworkChannel::SyncNetworkChannel()
 134     : last_network_status_(false),
 135       received_messages_count_(0) {}
 136
 137 SyncNetworkChannel::~SyncNetworkChannel() {
 138   STLDeleteElements(&network_status_receivers_);
 139 }
 140
 141 void SyncNetworkChannel::SetMessageReceiver(
 142     invalidation::MessageCallback* incoming_receiver) {
 143   incoming_receiver_.reset(incoming_receiver);
 144 }
 145
 146 void SyncNetworkChannel::AddNetworkStatusReceiver(
 147     invalidation::NetworkStatusCallback* network_status_receiver) {
 148   network_status_receiver->Run(last_network_status_);
 149   network_status_receivers_.push_back(network_status_receiver);
 150 }
 151
 152 void SyncNetworkChannel::SetSystemResources(
 153     invalidation::SystemResources* resources) {
 154   // Do nothing.
 155 }
 156
 157 void SyncNetworkChannel::AddObserver(Observer* observer) {
 158   observers_.AddObserver(observer);
 159 }
 160
 161 void SyncNetworkChannel::RemoveObserver(Observer* observer) {
 162   observers_.RemoveObserver(observer);
 163 }
 164
 165 scoped_ptr<SyncNetworkChannel> SyncNetworkChannel::CreatePushClientChannel(
 166     const notifier::NotifierOptions& notifier_options) {
 167   scoped_ptr<notifier::PushClient> push_client(
 168       notifier::PushClient::CreateDefaultOnIOThread(notifier_options));
 169   return scoped_ptr<SyncNetworkChannel>(
 170       new PushClientChannel(push_client.Pass()));
 171 }
 172
 173 scoped_ptr<SyncNetworkChannel> SyncNetworkChannel::CreateGCMNetworkChannel(
 174     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
 175     scoped_ptr<GCMNetworkChannelDelegate> delegate) {
 176   return scoped_ptr<SyncNetworkChannel>(new GCMNetworkChannel(
 177       request_context_getter, delegate.Pass()));
 178 }
 179
 180 void SyncNetworkChannel::NotifyNetworkStatusChange(bool online) {
 181   // Remember network state for future NetworkStatusReceivers.
 182   last_network_status_ = online;
 183   // Notify NetworkStatusReceivers in cacheinvalidation.
 184   for (NetworkStatusReceiverList::const_iterator it =
 185            network_status_receivers_.begin();
 186        it != network_status_receivers_.end(); ++it) {
 187     (*it)->Run(online);
 188   }
 189 }
 190
 191 void SyncNetworkChannel::NotifyChannelStateChange(
 192     InvalidatorState invalidator_state) {
 193   FOR_EACH_OBSERVER(Observer, observers_,
 194                     OnNetworkChannelStateChanged(invalidator_state));
 195 }
 196
 197 bool SyncNetworkChannel::DeliverIncomingMessage(const std::string& message) {
 198   if (!incoming_receiver_) {
 199     DLOG(ERROR) << "No receiver for incoming notification";
 200     return false;
 201   }
 202   received_messages_count_++;
 203   incoming_receiver_->Run(message);
 204   return true;
 205 }
 206
 207 int SyncNetworkChannel::GetReceivedMessagesCount() const {
 208   return received_messages_count_;
 209 }
 210
 211 SyncStorage::SyncStorage(StateWriter* state_writer,
 212                          invalidation::Scheduler* scheduler)
 213     : state_writer_(state_writer),
 214       scheduler_(scheduler) {
 215   DCHECK(state_writer_);
 216   DCHECK(scheduler_);
 217 }
 218
 219 SyncStorage::~SyncStorage() {}
 220
 221 void SyncStorage::WriteKey(const std::string& key, const std::string& value,
 222                            invalidation::WriteKeyCallback* done) {
 223   CHECK(state_writer_);
 224   // TODO(ghc): actually write key,value associations, and don't invoke the
 225   // callback until the operation completes.
 226   state_writer_->WriteState(value);
 227   cached_state_ = value;
 228   // According to the cache invalidation API folks, we can do this as
 229   // long as we make sure to clear the persistent state that we start
 230   // up the cache invalidation client with.  However, we musn't do it
 231   // right away, as we may be called under a lock that the callback
 232   // uses.
 233   scheduler_->Schedule(
 234       invalidation::Scheduler::NoDelay(),
 235       invalidation::NewPermanentCallback(
 236           this, &SyncStorage::RunAndDeleteWriteKeyCallback,
 237           done));
 238 }
 239
 240 void SyncStorage::ReadKey(const std::string& key,
 241                           invalidation::ReadKeyCallback* done) {
 242   DCHECK(scheduler_->IsRunningOnThread()) << "not running on scheduler thread";
 243   RunAndDeleteReadKeyCallback(done, cached_state_);
 244 }
 245
 246 void SyncStorage::DeleteKey(const std::string& key,
 247                             invalidation::DeleteKeyCallback* done) {
 248   // TODO(ghc): Implement.
 249   LOG(WARNING) << "ignoring call to DeleteKey(" << key << ", callback)";
 250 }
 251
 252 void SyncStorage::ReadAllKeys(invalidation::ReadAllKeysCallback* done) {
 253   // TODO(ghc): Implement.
 254   LOG(WARNING) << "ignoring call to ReadAllKeys(callback)";
 255 }
 256
 257 void SyncStorage::SetSystemResources(
 258     invalidation::SystemResources* resources) {
 259   // Do nothing.
 260 }
 261
 262 void SyncStorage::RunAndDeleteWriteKeyCallback(
 263     invalidation::WriteKeyCallback* callback) {
 264   callback->Run(
 265       invalidation::Status(invalidation::Status::SUCCESS, std::string()));
 266   delete callback;
 267 }
 268
 269 void SyncStorage::RunAndDeleteReadKeyCallback(
 270     invalidation::ReadKeyCallback* callback, const std::string& value) {
 271   callback->Run(std::make_pair(
 272       invalidation::Status(invalidation::Status::SUCCESS, std::string()),
 273       value));
 274   delete callback;
 275 }
 276
 277 SyncSystemResources::SyncSystemResources(
 278     SyncNetworkChannel* sync_network_channel,
 279     StateWriter* state_writer)
 280     : is_started_(false),
 281       logger_(new SyncLogger()),
 282       internal_scheduler_(new SyncInvalidationScheduler()),
 283       listener_scheduler_(new SyncInvalidationScheduler()),
 284       storage_(new SyncStorage(state_writer, internal_scheduler_.get())),
 285       sync_network_channel_(sync_network_channel) {
 286 }
 287
 288 SyncSystemResources::~SyncSystemResources() {
 289   Stop();
 290 }
 291
 292 void SyncSystemResources::Start() {
 293   internal_scheduler_->Start();
 294   listener_scheduler_->Start();
 295   is_started_ = true;
 296 }
 297
 298 void SyncSystemResources::Stop() {
 299   internal_scheduler_->Stop();
 300   listener_scheduler_->Stop();
 301 }
 302
 303 bool SyncSystemResources::IsStarted() const {
 304   return is_started_;
 305 }
 306
 307 void SyncSystemResources::set_platform(const std::string& platform) {
 308   platform_ = platform;
 309 }
 310
 311 std::string SyncSystemResources::platform() const {
 312   return platform_;
 313 }
 314
 315 SyncLogger* SyncSystemResources::logger() {
 316   return logger_.get();
 317 }
 318
 319 SyncStorage* SyncSystemResources::storage() {
 320   return storage_.get();
 321 }
 322
 323 SyncNetworkChannel* SyncSystemResources::network() {
 324   return sync_network_channel_;
 325 }
 326
 327 SyncInvalidationScheduler* SyncSystemResources::internal_scheduler() {
 328   return internal_scheduler_.get();
 329 }
 330
 331 SyncInvalidationScheduler* SyncSystemResources::listener_scheduler() {
 332   return listener_scheduler_.get();
 333 }
 334
 335 }  // namespace syncer