Persist Instance ID data to GCM store.

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 69 matching lines @@
             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);
+  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);
 
   // 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 236 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::AddInstanceIDData(
+    const std::string& app_id,
+    const std::string& instance_id_data) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  if (gcm_client_.get())
+    gcm_client_->AddInstanceIDData(app_id, instance_id_data);
+}
+
+void GCMDriverDesktop::IOWorker::RemoveInstanceIDData(
+    const std::string& app_id) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  if (gcm_client_.get())
+    gcm_client_->RemoveInstanceIDData(app_id);
+}
+
+void GCMDriverDesktop::IOWorker::GetInstanceIDData(
+    const std::string& app_id) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  std::string instance_id_data;
+  if (gcm_client_.get())
+    instance_id_data = gcm_client_->GetInstanceIDData(app_id);
+
+  ui_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::GetInstanceIDDataFinished,
+                 service_, app_id, instance_id_data));
+}
+
 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::SimpleAlarmTimer());
   else
     timer.reset(new base::Timer(true, false));
 
@@ skipping 296 matching lines @@
 
   last_token_fetch_time_ = time;
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::SetLastTokenFetchTime,
                  base::Unretained(io_worker_.get()),
                  time));
 }
 
+InstanceIDStore* GCMDriverDesktop::GetInstanceIDStore() {
+  return this;
+}
+
+void GCMDriverDesktop::AddInstanceIDData(
+    const std::string& app_id,
+    const std::string& instance_id_data) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::AddInstanceIDData,
+                 base::Unretained(io_worker_.get()),
+                 app_id,
+                 instance_id_data));
+}
+
+void GCMDriverDesktop::RemoveInstanceIDData(const std::string& app_id) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::RemoveInstanceIDData,
+                 base::Unretained(io_worker_.get()),
+                 app_id));
+}
+
+void GCMDriverDesktop::GetInstanceIDData(
+    const std::string& app_id,
+    const GetInstanceIDDataCallback& callback) {
+  DCHECK(!get_instance_id_data_callbacks_.count(app_id));
+  get_instance_id_data_callbacks_[app_id] = callback;
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::GetInstanceIDData,
+                 base::Unretained(io_worker_.get()),
+                 app_id));
+}
+
+void GCMDriverDesktop::GetInstanceIDDataFinished(
+    const std::string& app_id,
+    const std::string& instance_id_data) {
+  DCHECK(get_instance_id_data_callbacks_.count(app_id));
+  get_instance_id_data_callbacks_[app_id].Run(instance_id_data);
+  get_instance_id_data_callbacks_.erase(app_id);
+}
+
 void GCMDriverDesktop::WakeFromSuspendForHeartbeat(bool wake) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   wake_from_suspend_enabled_ = wake;
 
   // The GCM service has not been initialized.
   if (!delayed_task_controller_)
     return;
 
   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
@@ skipping 169 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