Link GCM heartbeat with wake on wifi preference

components/gcm_driver/gcm_driver_desktop.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/gcm_driver/gcm_driver_desktop.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/gcm_driver/gcm_account_mapper.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 #include "components/gcm_driver/gcm_channel_status_syncer.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "components/gcm_driver/gcm_delayed_task_controller.h"
 #include "components/gcm_driver/system_encryptor.h"
 #include "google_apis/gcm/engine/account_mapping.h"
 #include "net/base/ip_endpoint.h"
 #include "net/url_request/url_request_context_getter.h"
 
+#if defined(OS_CHROMEOS)
+#include "components/timers/alarm_timer.h"
+#endif
+
 namespace gcm {
 
 class GCMDriverDesktop::IOWorker : public GCMClient::Delegate {
  public:
   // Called on UI thread.
   IOWorker(const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
            const scoped_refptr<base::SequencedTaskRunner>& io_thread);
   virtual ~IOWorker();
 
   // Overridden from GCMClient::Delegate:
@@ skipping 37 matching lines @@
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message);
   void GetGCMStatistics(bool clear_logs);
   void SetGCMRecording(bool recording);
 
   void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens);
   void UpdateAccountMapping(const AccountMapping& account_mapping);
   void RemoveAccountMapping(const std::string& account_id);
   void SetLastTokenFetchTime(const base::Time& time);
+  void WakeFromSuspendForHeartbeat(bool wake);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> io_thread_;
 
   base::WeakPtr<GCMDriverDesktop> service_;
 
@@ skipping 240 matching lines @@
     gcm_client_->RemoveAccountMapping(account_id);
 }
 
 void GCMDriverDesktop::IOWorker::SetLastTokenFetchTime(const base::Time& time) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   if (gcm_client_.get())
     gcm_client_->SetLastTokenFetchTime(time);
 }
 
+void GCMDriverDesktop::IOWorker::WakeFromSuspendForHeartbeat(bool wake) {
+#if defined(OS_CHROMEOS)
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  scoped_ptr<base::Timer> timer;
+  if (wake)
+    timer.reset(new timers::AlarmTimer(true, false));
+  else
+    timer.reset(new base::Timer(true, false));
+
+  gcm_client_->UpdateHeartbeatTimer(timer.Pass());
+#endif
+}
+
 GCMDriverDesktop::GCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     const std::string& channel_status_request_url,
     const std::string& user_agent,
     PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner)
     : gcm_channel_status_syncer_(
           new GCMChannelStatusSyncer(this,
                                      prefs,
                                      channel_status_request_url,
                                      user_agent,
                                      request_context)),
       signed_in_(false),
       gcm_started_(false),
       gcm_enabled_(true),
       connected_(false),
       account_mapper_(new GCMAccountMapper(this)),
       // Setting to max, to make sure it does not prompt for token reporting
       // Before reading a reasonable value from the DB, which might be never,
       // in which case the fetching will be triggered.
       last_token_fetch_time_(base::Time::Max()),
       ui_thread_(ui_thread),
       io_thread_(io_thread),
+      wake_from_suspend_enabled_(false),
       weak_ptr_factory_(this) {
   gcm_enabled_ = gcm_channel_status_syncer_->gcm_enabled();
 
   // Create and initialize the GCMClient. Note that this does not initiate the
   // GCM check-in.
   io_worker_.reset(new IOWorker(ui_thread, io_thread));
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Initialize,
                  base::Unretained(io_worker_.get()),
@@ skipping 270 matching lines @@
 
   last_token_fetch_time_ = time;
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::SetLastTokenFetchTime,
                  base::Unretained(io_worker_.get()),
                  time));
 }
 
+void GCMDriverDesktop::WakeFromSuspendForHeartbeat(bool wake) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  wake_from_suspend_enabled_ = wake;
+  if (!IsStarted())
+    return;
+
+  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
+    // The GCM service has started but the client is not ready yet.
+    delayed_task_controller_->AddTask(
+        base::Bind(&GCMDriverDesktop::WakeFromSuspendForHeartbeat,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   wake_from_suspend_enabled_));
+    return;
+  }
+
+  // The GCMClient is ready so we can go ahead and post this task to the
+  // IOWorker.
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::WakeFromSuspendForHeartbeat,
+                 base::Unretained(io_worker_.get()),
+                 wake_from_suspend_enabled_));
+}
+
 void GCMDriverDesktop::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   account_mapper_->SetAccountTokens(account_tokens);
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::SetAccountTokens,
                  base::Unretained(io_worker_.get()),
@@ skipping 35 matching lines @@
 
   // Note that we need to pass weak pointer again since the existing weak
   // pointer in IOWorker might have been invalidated when check-out occurs.
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Start,
                  base::Unretained(io_worker_.get()),
                  weak_ptr_factory_.GetWeakPtr()));
 
   gcm_started_ = true;
+  if (wake_from_suspend_enabled_)
+    WakeFromSuspendForHeartbeat(wake_from_suspend_enabled_);
+
   return GCMClient::SUCCESS;
 }
 
 void GCMDriverDesktop::RemoveCachedData() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   // Remove all the queued tasks since they no longer make sense after
   // GCM service is stopped.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   gcm_started_ = false;
@@ skipping 91 matching lines @@
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // Normally request_gcm_statistics_callback_ would not be null.
   if (!request_gcm_statistics_callback_.is_null())
     request_gcm_statistics_callback_.Run(stats);
   else
     LOG(WARNING) << "request_gcm_statistics_callback_ is NULL.";
 }
 
 }  // namespace gcm
-