[GCM] Wiring heartbeat interval calls to GCMDriver

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"
@@ skipping 73 matching lines @@
   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);
   void AddInstanceIDData(const std::string& app_id,
                          const std::string& instance_id_data);
   void RemoveInstanceIDData(const std::string& app_id);
   void GetInstanceIDData(const std::string& app_id);
+  void AddHeartbeatInterval(const std::string& scope, int interval_ms);
+  void RemoveHeartbeatInterval(const std::string& scope);
 
   // 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 281 matching lines @@
   scoped_ptr<base::Timer> timer;
   if (wake)
     timer.reset(new timers::SimpleAlarmTimer());
   else
     timer.reset(new base::Timer(true, false));
 
   gcm_client_->UpdateHeartbeatTimer(timer.Pass());
 #endif
 }
 
+void GCMDriverDesktop::IOWorker::AddHeartbeatInterval(const std::string& scope,
+                                                      int interval_ms) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  gcm_client_->AddHeartbeatInterval(scope, interval_ms);
+}
+
+void GCMDriverDesktop::IOWorker::RemoveHeartbeatInterval(
+    const std::string& scope) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  gcm_client_->RemoveHeartbeatInterval(scope);
+}
+
 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,
@@ skipping 356 matching lines @@
 
   // 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::AddHeartbeatInterval(const std::string& scope,
+                                            int interval_ms) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  // The GCM service has not been initialized.
+  if (!delayed_task_controller_)
+    return;
+
+  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
+    // The GCM service was initialized but has not started yet.
+    delayed_task_controller_->AddTask(
+        base::Bind(&GCMDriverDesktop::AddHeartbeatInterval,
+                   weak_ptr_factory_.GetWeakPtr(), scope, interval_ms));
+    return;
+  }
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::AddHeartbeatInterval,
+                 base::Unretained(io_worker_.get()), scope, interval_ms));
+}
+
+void GCMDriverDesktop::RemoveHeartbeatInterval(const std::string& scope) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  // The GCM service has not been initialized.
+  if (!delayed_task_controller_)
+    return;
+
+  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
+    // The GCM service was initialized but has not started yet.
+    delayed_task_controller_->AddTask(
+        base::Bind(&GCMDriverDesktop::RemoveHeartbeatInterval,
+                   weak_ptr_factory_.GetWeakPtr(), scope));
+    return;
+  }
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::RemoveHeartbeatInterval,
+                 base::Unretained(io_worker_.get()), scope));
+}
+
 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 142 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