sync/notifier/chrome_system_resources.cc

   1 // Copyright (c) 2012 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 "sync/notifier/chrome_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.h"
  14 #include "base/stl_util.h"
  15 #include "base/string_util.h"
  16 #include "base/stringprintf.h"
  17 #include "google/cacheinvalidation/include/types.h"
  18 #include "sync/notifier/cache_invalidation_packet_handler.h"
  19 #include "sync/notifier/invalidation_util.h"
  20
  21 namespace sync_notifier {
  22
  23 ChromeLogger::ChromeLogger() {}
  24 ChromeLogger::~ChromeLogger() {}
  25
  26 void ChromeLogger::Log(LogLevel level, const char* file, int line,
  27                        const char* format, ...) {
  28   logging::LogSeverity log_severity = -2;  // VLOG(2)
  29   bool emit_log = false;
  30   switch (level) {
  31     case FINE_LEVEL:
  32       log_severity = -2;  // VLOG(2)
  33       emit_log = VLOG_IS_ON(2);
  34       break;
  35     case INFO_LEVEL:
  36       log_severity = -1;  // VLOG(1)
  37       emit_log = VLOG_IS_ON(1);
  38       break;
  39     case WARNING_LEVEL:
  40       log_severity = logging::LOG_WARNING;
  41       emit_log = LOG_IS_ON(WARNING);
  42       break;
  43     case SEVERE_LEVEL:
  44       log_severity = logging::LOG_ERROR;
  45       emit_log = LOG_IS_ON(ERROR);
  46       break;
  47   }
  48   if (emit_log) {
  49     va_list ap;
  50     va_start(ap, format);
  51     std::string result;
  52     base::StringAppendV(&result, format, ap);
  53     logging::LogMessage(file, line, log_severity).stream() << result;
  54     va_end(ap);
  55   }
  56 }
  57
  58 void ChromeLogger::SetSystemResources(
  59     invalidation::SystemResources* resources) {
  60   // Do nothing.
  61 }
  62
  63 ChromeScheduler::ChromeScheduler()
  64     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
  65       created_on_loop_(MessageLoop::current()),
  66       is_started_(false),
  67       is_stopped_(false) {
  68   CHECK(created_on_loop_);
  69 }
  70
  71 ChromeScheduler::~ChromeScheduler() {
  72   CHECK_EQ(created_on_loop_, MessageLoop::current());
  73   CHECK(is_stopped_);
  74 }
  75
  76 void ChromeScheduler::Start() {
  77   CHECK_EQ(created_on_loop_, MessageLoop::current());
  78   CHECK(!is_started_);
  79   is_started_ = true;
  80   is_stopped_ = false;
  81   weak_factory_.InvalidateWeakPtrs();
  82 }
  83
  84 void ChromeScheduler::Stop() {
  85   CHECK_EQ(created_on_loop_, MessageLoop::current());
  86   is_stopped_ = true;
  87   is_started_ = false;
  88   weak_factory_.InvalidateWeakPtrs();
  89   STLDeleteElements(&posted_tasks_);
  90   posted_tasks_.clear();
  91 }
  92
  93 void ChromeScheduler::Schedule(invalidation::TimeDelta delay,
  94                                invalidation::Closure* task) {
  95   DCHECK(invalidation::IsCallbackRepeatable(task));
  96   CHECK_EQ(created_on_loop_, MessageLoop::current());
  97
  98   if (!is_started_) {
  99     delete task;
 100     return;
 101   }
 102
 103   posted_tasks_.insert(task);
 104   MessageLoop::current()->PostDelayedTask(
 105       FROM_HERE, base::Bind(&ChromeScheduler::RunPostedTask,
 106                             weak_factory_.GetWeakPtr(), task),
 107       delay);
 108 }
 109
 110 bool ChromeScheduler::IsRunningOnThread() const {
 111   return created_on_loop_ == MessageLoop::current();
 112 }
 113
 114 invalidation::Time ChromeScheduler::GetCurrentTime() const {
 115   CHECK_EQ(created_on_loop_, MessageLoop::current());
 116   return base::Time::Now();
 117 }
 118
 119 void ChromeScheduler::SetSystemResources(
 120     invalidation::SystemResources* resources) {
 121   // Do nothing.
 122 }
 123
 124 void ChromeScheduler::RunPostedTask(invalidation::Closure* task) {
 125   CHECK_EQ(created_on_loop_, MessageLoop::current());
 126   RunAndDeleteClosure(task);
 127   posted_tasks_.erase(task);
 128 }
 129
 130 ChromeStorage::ChromeStorage(StateWriter* state_writer,
 131                              invalidation::Scheduler* scheduler)
 132     : state_writer_(state_writer),
 133       scheduler_(scheduler) {
 134   DCHECK(state_writer_);
 135   DCHECK(scheduler_);
 136 }
 137
 138 ChromeStorage::~ChromeStorage() {}
 139
 140 void ChromeStorage::WriteKey(const std::string& key, const std::string& value,
 141                              invalidation::WriteKeyCallback* done) {
 142   CHECK(state_writer_);
 143   // TODO(ghc): actually write key,value associations, and don't invoke the
 144   // callback until the operation completes.
 145   state_writer_->WriteState(value);
 146   cached_state_ = value;
 147   // According to the cache invalidation API folks, we can do this as
 148   // long as we make sure to clear the persistent state that we start
 149   // up the cache invalidation client with.  However, we musn't do it
 150   // right away, as we may be called under a lock that the callback
 151   // uses.
 152   scheduler_->Schedule(
 153       invalidation::Scheduler::NoDelay(),
 154       invalidation::NewPermanentCallback(
 155           this, &ChromeStorage::RunAndDeleteWriteKeyCallback,
 156           done));
 157 }
 158
 159 void ChromeStorage::ReadKey(const std::string& key,
 160                             invalidation::ReadKeyCallback* done) {
 161   DCHECK(scheduler_->IsRunningOnThread()) << "not running on scheduler thread";
 162   RunAndDeleteReadKeyCallback(done, cached_state_);
 163 }
 164
 165 void ChromeStorage::DeleteKey(const std::string& key,
 166                               invalidation::DeleteKeyCallback* done) {
 167   // TODO(ghc): Implement.
 168   LOG(WARNING) << "ignoring call to DeleteKey(" << key << ", callback)";
 169 }
 170
 171 void ChromeStorage::ReadAllKeys(invalidation::ReadAllKeysCallback* done) {
 172   // TODO(ghc): Implement.
 173   LOG(WARNING) << "ignoring call to ReadAllKeys(callback)";
 174 }
 175
 176 void ChromeStorage::SetSystemResources(
 177     invalidation::SystemResources* resources) {
 178   // Do nothing.
 179 }
 180
 181 void ChromeStorage::RunAndDeleteWriteKeyCallback(
 182     invalidation::WriteKeyCallback* callback) {
 183   callback->Run(invalidation::Status(invalidation::Status::SUCCESS, ""));
 184   delete callback;
 185 }
 186
 187 void ChromeStorage::RunAndDeleteReadKeyCallback(
 188     invalidation::ReadKeyCallback* callback, const std::string& value) {
 189   callback->Run(std::make_pair(
 190       invalidation::Status(invalidation::Status::SUCCESS, ""),
 191       value));
 192   delete callback;
 193 }
 194
 195 ChromeNetwork::ChromeNetwork()
 196     : packet_handler_(NULL),
 197       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 198
 199 ChromeNetwork::~ChromeNetwork() {
 200   STLDeleteElements(&network_status_receivers_);
 201 }
 202
 203 void ChromeNetwork::SendMessage(const std::string& outgoing_message) {
 204   if (packet_handler_) {
 205     packet_handler_->SendMessage(outgoing_message);
 206   }
 207 }
 208
 209 void ChromeNetwork::SetMessageReceiver(
 210     invalidation::MessageCallback* incoming_receiver) {
 211   incoming_receiver_.reset(incoming_receiver);
 212 }
 213
 214 void ChromeNetwork::AddNetworkStatusReceiver(
 215     invalidation::NetworkStatusCallback* network_status_receiver) {
 216   network_status_receivers_.push_back(network_status_receiver);
 217 }
 218
 219 void ChromeNetwork::SetSystemResources(
 220     invalidation::SystemResources* resources) {
 221   // Do nothing.
 222 }
 223
 224 void ChromeNetwork::UpdatePacketHandler(
 225     CacheInvalidationPacketHandler* packet_handler) {
 226   packet_handler_ = packet_handler;
 227   if (packet_handler_ != NULL) {
 228     packet_handler_->SetMessageReceiver(
 229         new invalidation::MessageCallback(
 230             base::Bind(&ChromeNetwork::HandleInboundMessage,
 231                        weak_factory_.GetWeakPtr())));
 232   }
 233   packet_handler_->SendSubscriptionRequest();
 234 }
 235
 236 void ChromeNetwork::HandleInboundMessage(const std::string& incoming_message) {
 237   if (incoming_receiver_.get()) {
 238     incoming_receiver_->Run(incoming_message);
 239   }
 240 }
 241
 242 ChromeSystemResources::ChromeSystemResources(StateWriter* state_writer)
 243     : is_started_(false),
 244       logger_(new ChromeLogger()),
 245       internal_scheduler_(new ChromeScheduler()),
 246       listener_scheduler_(new ChromeScheduler()),
 247       storage_(new ChromeStorage(state_writer, internal_scheduler_.get())),
 248       network_(new ChromeNetwork()) {
 249 }
 250
 251 ChromeSystemResources::~ChromeSystemResources() {
 252   Stop();
 253 }
 254
 255 void ChromeSystemResources::Start() {
 256   internal_scheduler_->Start();
 257   listener_scheduler_->Start();
 258   is_started_ = true;
 259 }
 260
 261 void ChromeSystemResources::Stop() {
 262   internal_scheduler_->Stop();
 263   listener_scheduler_->Stop();
 264 }
 265
 266 bool ChromeSystemResources::IsStarted() const {
 267   return is_started_;
 268 }
 269
 270 void ChromeSystemResources::set_platform(const std::string& platform) {
 271   platform_ = platform;
 272 }
 273
 274 std::string ChromeSystemResources::platform() const {
 275   return platform_;
 276 }
 277
 278 ChromeLogger* ChromeSystemResources::logger() {
 279   return logger_.get();
 280 }
 281
 282 ChromeStorage* ChromeSystemResources::storage() {
 283   return storage_.get();
 284 }
 285
 286 ChromeNetwork* ChromeSystemResources::network() {
 287   return network_.get();
 288 }
 289
 290 ChromeScheduler* ChromeSystemResources::internal_scheduler() {
 291   return internal_scheduler_.get();
 292 }
 293
 294 ChromeScheduler* ChromeSystemResources::listener_scheduler() {
 295   return listener_scheduler_.get();
 296 }
 297
 298 }  // namespace sync_notifier