Support getting and deleting token for Instance ID.

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/profiler/scoped_tracker.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/instance_id/instance_id_impl.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_chromeos.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:
   // Called on IO thread.
-  void OnRegisterFinished(const std::string& app_id,
+  void OnRegisterFinished(const linked_ptr<RegistrationInfo>& registration_info,
                           const std::string& registration_id,
                           GCMClient::Result result) override;
-  void OnUnregisterFinished(const std::string& app_id,
-                            GCMClient::Result result) override;
+  void OnUnregisterFinished(
+      const linked_ptr<RegistrationInfo>& registration_info,
+      GCMClient::Result result) override;
   void OnSendFinished(const std::string& app_id,
                       const std::string& message_id,
                       GCMClient::Result result) override;
   void OnMessageReceived(const std::string& app_id,
                          const GCMClient::IncomingMessage& message) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
   void OnSendAcknowledged(const std::string& app_id,
@@ skipping 23 matching lines @@
   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);
+                         const std::string& instance_id,
+                         const std::string& extra_data);
   void RemoveInstanceIDData(const std::string& app_id);
   void GetInstanceIDData(const std::string& app_id);
+  void GetToken(const std::string& app_id,
+                const std::string& authorized_entity,
+                const std::string& scope,
+                const std::map<std::string, std::string>& options);
+  void DeleteToken(const std::string& app_id,
+                   const std::string& authorized_entity,
+                   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 30 matching lines @@
 
   gcm_client_->Initialize(chrome_build_info,
                           store_path,
                           blocking_task_runner,
                           request_context,
                           make_scoped_ptr<Encryptor>(new SystemEncryptor),
                           this);
 }
 
 void GCMDriverDesktop::IOWorker::OnRegisterFinished(
-    const std::string& app_id,
+    const linked_ptr<RegistrationInfo>& registration_info,
     const std::string& registration_id,
     GCMClient::Result result) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
-  ui_thread_->PostTask(
+  const GCMRegistrationInfo* gcm_registration_info =
+      GCMRegistrationInfo::FromRegistrationInfo(registration_info.get());
+  if (gcm_registration_info) {
+    ui_thread_->PostTask(
+        FROM_HERE,
+        base::Bind(&GCMDriverDesktop::RegisterFinished,
+                   service_,
+                   gcm_registration_info->app_id,
+                   registration_id,
+                   result));
+  }
+
+  const InstanceIDTokenInfo* instance_id_token_info =
+      InstanceIDTokenInfo::FromRegistrationInfo(registration_info.get());
+  if (instance_id_token_info) {
+    ui_thread_->PostTask(
       FROM_HERE,
-      base::Bind(&GCMDriverDesktop::RegisterFinished, service_, app_id,
-                 registration_id, result));
+      base::Bind(&GCMDriverDesktop::GetTokenFinished,
+                 service_,
+                 instance_id_token_info->app_id,
+                 instance_id_token_info->authorized_entity,
+                 instance_id_token_info->scope,
+                 registration_id,
+                 result));
+  }
 }
 
 void GCMDriverDesktop::IOWorker::OnUnregisterFinished(
-    const std::string& app_id,
+    const linked_ptr<RegistrationInfo>& registration_info,
     GCMClient::Result result) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   ui_thread_->PostTask(FROM_HERE,
                        base::Bind(&GCMDriverDesktop::UnregisterFinished,
                                   service_,
-                                  app_id,
+                                  registration_info->app_id,
                                   result));
 }
 
 void GCMDriverDesktop::IOWorker::OnSendFinished(const std::string& app_id,
                                                 const std::string& message_id,
                                                 GCMClient::Result result) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   ui_thread_->PostTask(
       FROM_HERE,
@@ skipping 87 matching lines @@
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   gcm_client_->Stop();
 }
 
 void GCMDriverDesktop::IOWorker::Register(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
-  gcm_client_->Register(app_id, sender_ids);
+  scoped_ptr<GCMRegistrationInfo> gcm_info(new GCMRegistrationInfo);
+  gcm_info->app_id = app_id;
+  gcm_info->sender_ids = sender_ids;
+  gcm_client_->Register(make_linked_ptr<RegistrationInfo>(gcm_info.release()));
 }
 
 void GCMDriverDesktop::IOWorker::Unregister(const std::string& app_id) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
-  gcm_client_->Unregister(app_id);
+  scoped_ptr<GCMRegistrationInfo> gcm_info(new GCMRegistrationInfo);
+  gcm_info->app_id = app_id;
+  gcm_client_->Unregister(
+      make_linked_ptr<RegistrationInfo>(gcm_info.release()));
 }
 
 void GCMDriverDesktop::IOWorker::Send(
     const std::string& app_id,
     const std::string& receiver_id,
     const GCMClient::OutgoingMessage& message) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   gcm_client_->Send(app_id, receiver_id, message);
 }
@@ skipping 54 matching lines @@
 
 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) {
+    const std::string& instance_id,
+    const std::string& extra_data) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   if (gcm_client_.get())
-    gcm_client_->AddInstanceIDData(app_id, instance_id_data);
+    gcm_client_->AddInstanceIDData(app_id, instance_id, extra_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;
+  std::string instance_id;
+  std::string extra_data;
   if (gcm_client_.get())
-    instance_id_data = gcm_client_->GetInstanceIDData(app_id);
+    gcm_client_->GetInstanceIDData(app_id, &instance_id, &extra_data);
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::GetInstanceIDDataFinished,
-                 service_, app_id, instance_id_data));
+                 service_, app_id, instance_id, extra_data));
+}
+
+void GCMDriverDesktop::IOWorker::GetToken(
+    const std::string& app_id,
+    const std::string& authorized_entity,
+    const std::string& scope,
+    const std::map<std::string, std::string>& options) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  scoped_ptr<InstanceIDTokenInfo> instance_id_token_info(
+      new InstanceIDTokenInfo);
+  instance_id_token_info->app_id = app_id;
+  instance_id_token_info->authorized_entity = authorized_entity;
+  instance_id_token_info->scope = scope;
+  instance_id_token_info->options = options;
+  gcm_client_->Register(
+      make_linked_ptr<RegistrationInfo>(instance_id_token_info.release()));
+}
+
+void GCMDriverDesktop::IOWorker::DeleteToken(
+    const std::string& app_id,
+    const std::string& authorized_entity,
+    const std::string& scope) {
+  scoped_ptr<InstanceIDTokenInfo> instance_id_token_info(
+      new InstanceIDTokenInfo);
+  instance_id_token_info->app_id = app_id;
+  instance_id_token_info->authorized_entity = authorized_entity;
+  instance_id_token_info->scope = scope;
+  gcm_client_->Unregister(
+      make_linked_ptr<RegistrationInfo>(instance_id_token_info.release()));
 }
 
 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
@@ skipping 298 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() {
+InstanceIDHandler* GCMDriverDesktop::GetInstanceIDHandler() {
   return this;
 }
 
+void GCMDriverDesktop::GetToken(
+    const std::string& app_id,
+    const std::string& authorized_entity,
+    const std::string& scope,
+    const std::map<std::string, std::string>& options,
+    const GetTokenCallback& callback) {
+  DCHECK(!app_id.empty());
+  DCHECK(!authorized_entity.empty());
+  DCHECK(!scope.empty());
+  DCHECK(!callback.is_null());
+
+  GCMClient::Result result = EnsureStarted(GCMClient::IMMEDIATE_START);
+  if (result != GCMClient::SUCCESS) {
+    callback.Run(std::string(), result);
+    return;
+  }
+
+  // If previous GetToken operation is still in progress, bail out.
+  TokenTuple tuple_key(app_id, authorized_entity, scope);
+  if (get_token_callbacks_.find(tuple_key) != get_token_callbacks_.end()) {
+    callback.Run(std::string(), GCMClient::ASYNC_OPERATION_PENDING);
+    return;
+  }
+
+  get_token_callbacks_[tuple_key] = callback;
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::GetToken,
+                 base::Unretained(io_worker_.get()),
+                 app_id,
+                 authorized_entity,
+                 scope,
+                 options));
+}
+
+void GCMDriverDesktop::DeleteToken(const std::string& app_id,
+                                   const std::string& authorized_entity,
+                                   const std::string& scope,
+                                   const DeleteTokenCallback& callback) {
+  DCHECK(!app_id.empty());
+  DCHECK(!authorized_entity.empty());
+  DCHECK(!scope.empty());
+  DCHECK(!callback.is_null());
+
+  GCMClient::Result result = EnsureStarted(GCMClient::IMMEDIATE_START);
+  if (result != GCMClient::SUCCESS) {
+    callback.Run(result);
+    return;
+  }
+
+  // If previous GetToken operation is still in progress, bail out.
+  TokenTuple tuple_key(app_id, authorized_entity, scope);
+  if (delete_token_callbacks_.find(tuple_key) !=
+      delete_token_callbacks_.end()) {
+    callback.Run(GCMClient::ASYNC_OPERATION_PENDING);
+    return;
+  }
+
+  delete_token_callbacks_[tuple_key] = callback;
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::DeleteToken,
+                 base::Unretained(io_worker_.get()),
+                 app_id,
+                 authorized_entity,
+                 scope));
+}
+
 void GCMDriverDesktop::AddInstanceIDData(
     const std::string& app_id,
-    const std::string& instance_id_data) {
+    const std::string& instance_id,
+    const std::string& extra_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));
+                 instance_id,
+                 extra_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) {
+    const std::string& instance_id,
+    const std::string& extra_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_[app_id].Run(instance_id, extra_data);
   get_instance_id_data_callbacks_.erase(app_id);
 }
 
+void GCMDriverDesktop::GetTokenFinished(const std::string& app_id,
+                                        const std::string& authorized_entity,
+                                        const std::string& scope,
+                                        const std::string& token,
+                                        GCMClient::Result result) {
+  TokenTuple tuple_key(app_id, authorized_entity, scope);
+  auto callback_iter = get_token_callbacks_.find(tuple_key);
+  if (callback_iter == get_token_callbacks_.end()) {
+    // The callback could have been removed when the app is uninstalled.
+    return;
+  }
+
+  GetTokenCallback callback = callback_iter->second;
+  get_token_callbacks_.erase(callback_iter);
+  callback.Run(token, result);
+}
+
+void GCMDriverDesktop::DeleteTokenFinished(const std::string& app_id,
+                                           const std::string& authorized_entity,
+                                           const std::string& scope,
+                                           GCMClient::Result result) {
+  TokenTuple tuple_key(app_id, authorized_entity, scope);
+  auto callback_iter = delete_token_callbacks_.find(tuple_key);
+  if (callback_iter == delete_token_callbacks_.end()) {
+    // The callback could have been removed when the app is uninstalled.
+    return;
+  }
+
+  DeleteTokenCallback callback = callback_iter->second;
+  delete_token_callbacks_.erase(callback_iter);
+  callback.Run(result);
+}
+
 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 168 matching lines @@
     const GCMClient::GCMStatistics& stats) {
   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.";
 }
 
+bool GCMDriverDesktop::TokenTupleComparer::operator()(
+    const TokenTuple& a, const TokenTuple& b) const {
+  if (get<0>(a) < get<0>(b))
+    return true;
+  if (get<0>(a) > get<0>(b))
+    return false;
+
+  if (get<1>(a) < get<1>(b))
+    return true;
+  if (get<1>(a) > get<1>(b))
+    return false;
+
+  return get<2>(a) < get<2>(b);
+}
+
 }  // namespace gcm