Add support for GCM subtypes to desktop Instance ID implementation

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 83 matching lines @@
   void WakeFromSuspendForHeartbeat(bool wake);
   void AddHeartbeatInterval(const std::string& scope, int interval_ms);
   void RemoveHeartbeatInterval(const std::string& scope);
 
   void AddInstanceIDData(const std::string& app_id,
                          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,
+                bool use_subtype,
                 const std::string& authorized_entity,
                 const std::string& scope,
                 const std::map<std::string, std::string>& options);
   void DeleteToken(const std::string& app_id,
+                   bool use_subtype,
                    const std::string& authorized_entity,
                    const std::string& scope);
 
   void RecordDecryptionFailure(const std::string& app_id,
                                GCMEncryptionProvider::DecryptionResult result);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
@@ skipping 318 matching lines @@
     gcm_client_->GetInstanceIDData(app_id, &instance_id, &extra_data);
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::GetInstanceIDDataFinished,
                  service_, app_id, instance_id, extra_data));
 }
 
 void GCMDriverDesktop::IOWorker::GetToken(
     const std::string& app_id,
+    bool use_subtype,
     const std::string& authorized_entity,
     const std::string& scope,
     const std::map<std::string, std::string>& options) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   std::unique_ptr<InstanceIDTokenInfo> instance_id_token_info(
       new InstanceIDTokenInfo);
   instance_id_token_info->app_id = app_id;
+  instance_id_token_info->use_subtype = use_subtype;
   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,
+    bool use_subtype,
     const std::string& authorized_entity,
     const std::string& scope) {
   std::unique_ptr<InstanceIDTokenInfo> instance_id_token_info(
       new InstanceIDTokenInfo);
   instance_id_token_info->app_id = app_id;
+  instance_id_token_info->use_subtype = use_subtype;
   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());
 
@@ skipping 339 matching lines @@
                  base::Unretained(io_worker_.get()),
                  time));
 }
 
 InstanceIDHandler* GCMDriverDesktop::GetInstanceIDHandlerInternal() {
   return this;
 }
 
 void GCMDriverDesktop::GetToken(
     const std::string& app_id,
+    bool use_subtype,
     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());
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   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;
 
   // Delay the GetToken operation until GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
-    delayed_task_controller_->AddTask(
-        base::Bind(&GCMDriverDesktop::DoGetToken,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   app_id,
-                   authorized_entity,
-                   scope,
-                   options));
+    delayed_task_controller_->AddTask(base::Bind(
+        &GCMDriverDesktop::DoGetToken, weak_ptr_factory_.GetWeakPtr(), app_id,
+        use_subtype, authorized_entity, scope, options));
     return;
   }
 
-  DoGetToken(app_id, authorized_entity, scope, options);
+  DoGetToken(app_id, use_subtype, authorized_entity, scope, options);
 }
 
 void GCMDriverDesktop::DoGetToken(
     const std::string& app_id,
+    bool use_subtype,
     const std::string& authorized_entity,
     const std::string& scope,
     const std::map<std::string, std::string>& options) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   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;
   }
 
   io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriverDesktop::IOWorker::GetToken,
-                 base::Unretained(io_worker_.get()),
-                 app_id,
-                 authorized_entity,
-                 scope,
-                 options));
+      FROM_HERE, base::Bind(&GCMDriverDesktop::IOWorker::GetToken,
+                            base::Unretained(io_worker_.get()), app_id,
+                            use_subtype, authorized_entity, scope, options));
 }
 
 void GCMDriverDesktop::DeleteToken(const std::string& app_id,
+                                   bool use_subtype,
                                    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());
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   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;
 
   // Delay the DeleteToken operation until GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
-    delayed_task_controller_->AddTask(
-        base::Bind(&GCMDriverDesktop::DoDeleteToken,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   app_id,
-                   authorized_entity,
-                   scope));
+    delayed_task_controller_->AddTask(base::Bind(
+        &GCMDriverDesktop::DoDeleteToken, weak_ptr_factory_.GetWeakPtr(),
+        app_id, use_subtype, authorized_entity, scope));
     return;
   }
 
-  DoDeleteToken(app_id, authorized_entity, scope);
+  DoDeleteToken(app_id, use_subtype, authorized_entity, scope);
 }
 
 void GCMDriverDesktop::DoDeleteToken(const std::string& app_id,
+                                     bool use_subtype,
                                      const std::string& authorized_entity,
                                      const std::string& scope) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriverDesktop::IOWorker::DeleteToken,
-                 base::Unretained(io_worker_.get()),
-                 app_id,
-                 authorized_entity,
-                 scope));
+  io_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GCMDriverDesktop::IOWorker::DeleteToken,
+                                  base::Unretained(io_worker_.get()), app_id,
+                                  use_subtype, authorized_entity, scope));
 }
 
 void GCMDriverDesktop::AddInstanceIDData(
     const std::string& app_id,
     const std::string& instance_id,
     const std::string& extra_data) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   GCMClient::Result result = EnsureStarted(GCMClient::IMMEDIATE_START);
   if (result != GCMClient::SUCCESS)
@@ skipping 367 matching lines @@
 
   if (std::get<1>(a) < std::get<1>(b))
     return true;
   if (std::get<1>(a) > std::get<1>(b))
     return false;
 
   return std::get<2>(a) < std::get<2>(b);
 }
 
 }  // namespace gcm