[GCM] Run InstanceIDImpl callbacks asynchronously

components/gcm_driver/instance_id/instance_id_impl.cc

 // Copyright 2015 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/instance_id/instance_id_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "crypto/random.h"
 
 namespace instance_id {
 
 namespace {
 
 InstanceID::Result GCMClientResultToInstanceIDResult(
     gcm::GCMClient::Result result) {
   switch (result) {
@@ skipping 32 matching lines @@
     : InstanceID(app_id, gcm_driver), weak_ptr_factory_(this) {
   Handler()->GetInstanceIDData(
       app_id, base::Bind(&InstanceIDImpl::GetInstanceIDDataCompleted,
                          weak_ptr_factory_.GetWeakPtr()));
 }
 
 InstanceIDImpl::~InstanceIDImpl() {
 }
 
 void InstanceIDImpl::GetID(const GetIDCallback& callback) {
-  if (!delayed_task_controller_.CanRunTaskWithoutDelay()) {
-    delayed_task_controller_.AddTask(
-        base::Bind(&InstanceIDImpl::DoGetID,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
-    return;
-  }
-
-  DoGetID(callback);
+  RunWhenReady(base::Bind(&InstanceIDImpl::DoGetID,
+                          weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void InstanceIDImpl::DoGetID(const GetIDCallback& callback) {
   EnsureIDGenerated();
   callback.Run(id_);
 }
 
 void InstanceIDImpl::GetCreationTime(const GetCreationTimeCallback& callback) {
-  if (!delayed_task_controller_.CanRunTaskWithoutDelay()) {
-    delayed_task_controller_.AddTask(
-        base::Bind(&InstanceIDImpl::DoGetCreationTime,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
-    return;
-  }
-
-  DoGetCreationTime(callback);
+  RunWhenReady(base::Bind(&InstanceIDImpl::DoGetCreationTime,
+                          weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void InstanceIDImpl::DoGetCreationTime(
     const GetCreationTimeCallback& callback) {
   callback.Run(creation_time_);
 }
 
 void InstanceIDImpl::GetToken(
     const std::string& authorized_entity,
     const std::string& scope,
     const std::map<std::string, std::string>& options,
     const GetTokenCallback& callback) {
   DCHECK(!authorized_entity.empty());
   DCHECK(!scope.empty());
 
-  if (!delayed_task_controller_.CanRunTaskWithoutDelay()) {
-    delayed_task_controller_.AddTask(
-        base::Bind(&InstanceIDImpl::DoGetToken,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   authorized_entity,
-                   scope,
-                   options,
-                   callback));
-    return;
-  }
-
-  DoGetToken(authorized_entity, scope, options, callback);
+  RunWhenReady(base::Bind(&InstanceIDImpl::DoGetToken,
+                          weak_ptr_factory_.GetWeakPtr(), authorized_entity,
+                          scope, options, callback));
 }
 
 void InstanceIDImpl::DoGetToken(
     const std::string& authorized_entity,
     const std::string& scope,
     const std::map<std::string, std::string>& options,
     const GetTokenCallback& callback) {
   EnsureIDGenerated();
 
   Handler()->GetToken(app_id(), authorized_entity, scope, options,
                       base::Bind(&InstanceIDImpl::OnGetTokenCompleted,
                                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void InstanceIDImpl::ValidateToken(const std::string& authorized_entity,
                                    const std::string& scope,
                                    const std::string& token,
                                    const ValidateTokenCallback& callback) {
   DCHECK(!authorized_entity.empty());
   DCHECK(!scope.empty());
   DCHECK(!token.empty());
 
-  if (!delayed_task_controller_.CanRunTaskWithoutDelay()) {
-    delayed_task_controller_.AddTask(base::Bind(
-        &InstanceIDImpl::DoValidateToken, weak_ptr_factory_.GetWeakPtr(),
-        authorized_entity, scope, token, callback));
-    return;
-  }
-
-  DoValidateToken(authorized_entity, scope, token, callback);
+  RunWhenReady(base::Bind(&InstanceIDImpl::DoValidateToken,
+                          weak_ptr_factory_.GetWeakPtr(), authorized_entity,
+                          scope, token, callback));
 }
 
 void InstanceIDImpl::DoValidateToken(const std::string& authorized_entity,
                                      const std::string& scope,
                                      const std::string& token,
                                      const ValidateTokenCallback& callback) {
   if (id_.empty()) {
     callback.Run(false /* is_valid */);
     return;
   }
 
   Handler()->ValidateToken(app_id(), authorized_entity, scope, token, callback);
 }
 
 void InstanceIDImpl::DeleteTokenImpl(const std::string& authorized_entity,
                                      const std::string& scope,
                                      const DeleteTokenCallback& callback) {
   DCHECK(!authorized_entity.empty());
   DCHECK(!scope.empty());
 
-  if (!delayed_task_controller_.CanRunTaskWithoutDelay()) {
-    delayed_task_controller_.AddTask(
-        base::Bind(&InstanceIDImpl::DoDeleteToken,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   authorized_entity,
-                   scope,
-                   callback));
-    return;
-  }
-
-  DoDeleteToken(authorized_entity, scope, callback);
+  RunWhenReady(base::Bind(&InstanceIDImpl::DoDeleteToken,
+                          weak_ptr_factory_.GetWeakPtr(), authorized_entity,
+                          scope, callback));
 }
 
 void InstanceIDImpl::DoDeleteToken(
     const std::string& authorized_entity,
     const std::string& scope,
     const DeleteTokenCallback& callback) {
   // Nothing to delete if the ID has not been generated.
   if (id_.empty()) {
     callback.Run(InstanceID::INVALID_PARAMETER);
     return;
   }
 
   Handler()->DeleteToken(app_id(), authorized_entity, scope,
                         base::Bind(&InstanceIDImpl::OnDeleteTokenCompleted,
                                    weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void InstanceIDImpl::DeleteIDImpl(const DeleteIDCallback& callback) {
-  if (!delayed_task_controller_.CanRunTaskWithoutDelay()) {
-    delayed_task_controller_.AddTask(
-        base::Bind(&InstanceIDImpl::DoDeleteID,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
-    return;
-  }
-
-  DoDeleteID(callback);
+  RunWhenReady(base::Bind(&InstanceIDImpl::DoDeleteID,
+                          weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void InstanceIDImpl::DoDeleteID(const DeleteIDCallback& callback) {
   // Nothing to do if ID has not been generated.
   if (id_.empty()) {
     callback.Run(InstanceID::SUCCESS);
     return;
   }
 
   Handler()->DeleteAllTokensForApp(
@@ skipping 77 matching lines @@
       app_id(), id_, base::Int64ToString(creation_time_.ToInternalValue()));
 }
 
 gcm::InstanceIDHandler* InstanceIDImpl::Handler() {
   gcm::InstanceIDHandler* handler =
       gcm_driver()->GetInstanceIDHandlerInternal();
   DCHECK(handler);
   return handler;
 }
 
+void InstanceIDImpl::RunWhenReady(base::Closure task) {
+  if (!delayed_task_controller_.CanRunTaskWithoutDelay())
+    delayed_task_controller_.AddTask(task);
+  else
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);

[Peter Beverloo, 2017/04/03 17:45:01]

It's a bit unfortunate that this makes things asynchronous by delaying the
operation rather than posting the response.

The alternative is to update lines 77, 87, 133, 157, 174, 191, 197 and 203 with
PostTask()s. That's a bit fugly too :(

[johnme, 2017/04/03 17:50:43]

Acknowledged :)

+}
+
 }  // namespace instance_id