Change getAccessToken and getExtensionPrinterAccess to sendWithPromise

chrome/browser/ui/webui/print_preview/print_preview_handler.cc

Index: chrome/browser/ui/webui/print_preview/print_preview_handler.cc
diff --git a/chrome/browser/ui/webui/print_preview/print_preview_handler.cc b/chrome/browser/ui/webui/print_preview/print_preview_handler.cc
index b4ceb816e49a79177a1e882ae57422e66f952db4..10297ab43ea5517c87fa3adb2de1aa04546cebdd 100644
--- a/chrome/browser/ui/webui/print_preview/print_preview_handler.cc
+++ b/chrome/browser/ui/webui/print_preview/print_preview_handler.cc
@@ -476,9 +476,11 @@ class PrintPreviewHandler::AccessTokenService
         handler_(handler) {
   }
 
-  void RequestToken(const std::string& type) {
-    if (requests_.find(type) != requests_.end())
+  void RequestToken(const std::string& type, const std::string& callback_id) {
+    if (requests_.find(type) != requests_.end()) {
+      handler_->SendRequestInProgress(callback_id);
       return;  // Already in progress.
+    }
 
     OAuth2TokenService* service = NULL;
     std::string account_id;
@@ -507,29 +509,32 @@ class PrintPreviewHandler::AccessTokenService
       std::unique_ptr<OAuth2TokenService::Request> request(
           service->StartRequest(account_id, oauth_scopes, this));
       requests_[type] = std::move(request);
+      callbacks_[type] = callback_id;
     } else {
-      handler_->SendAccessToken(type, std::string());  // Unknown type.
+      // Unknown type.
+      handler_->SendAccessToken(callback_id, std::string());
     }
   }
 
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override {
-    OnServiceResponce(request, access_token);
+    OnServiceResponse(request, access_token);
   }
 
   void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                          const GoogleServiceAuthError& error) override {
-    OnServiceResponce(request, std::string());
+    OnServiceResponse(request, std::string());
   }
 
  private:
-  void OnServiceResponce(const OAuth2TokenService::Request* request,
+  void OnServiceResponse(const OAuth2TokenService::Request* request,
                          const std::string& access_token) {
     for (Requests::iterator i = requests_.begin(); i != requests_.end(); ++i) {
       if (i->second.get() == request) {
-        handler_->SendAccessToken(i->first, access_token);
+        handler_->SendAccessToken(callbacks_[i->first], access_token);
         requests_.erase(i);
+        callbacks_.erase(i->first);
         return;
       }
     }
@@ -539,6 +544,8 @@ class PrintPreviewHandler::AccessTokenService
   using Requests =
       std::map<std::string, std::unique_ptr<OAuth2TokenService::Request>>;
   Requests requests_;
+  using Callbacks = std::map<std::string, std::string>;
+  Callbacks callbacks_;
   PrintPreviewHandler* handler_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
@@ -745,14 +752,19 @@ void PrintPreviewHandler::HandleGetExtensionPrinters(
 
 void PrintPreviewHandler::HandleGrantExtensionPrinterAccess(
     const base::ListValue* args) {
+  std::string callback_id;
   std::string printer_id;
-  bool ok = args->GetString(0, &printer_id);
+  bool ok = args->GetString(0, &callback_id) && args->GetString(1, &printer_id);
   DCHECK(ok);
 
+  AllowJavascript();
+  if (callback_id.empty() || printer_id.empty())
+    RejectJavascriptCallback(base::Value(callback_id), base::Value());
+
   EnsureExtensionPrinterHandlerSet();
   extension_printer_handler_->StartGrantPrinterAccess(
       printer_id, base::Bind(&PrintPreviewHandler::OnGotExtensionPrinterInfo,
-                             weak_factory_.GetWeakPtr(), printer_id));
+                             weak_factory_.GetWeakPtr(), callback_id));
 }
 
 void PrintPreviewHandler::HandleGetExtensionPrinterCapabilities(
@@ -1154,12 +1166,18 @@ void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
 }
 
 void PrintPreviewHandler::HandleGetAccessToken(const base::ListValue* args) {
+  std::string callback_id;
   std::string type;
-  if (!args->GetString(0, &type))
+
+  AllowJavascript();
+  if (!args->GetString(0, &callback_id) || !args->GetString(1, &type)) {

[dpapad, 2017/06/15 22:20:13]

Can this happen other than programmer's error? Should this be a CHECK/DCHECK
instead?

[rbpotter, 2017/06/16 02:19:36]

Done.

+    RejectJavascriptCallback(base::Value(callback_id), base::Value());
     return;
+  }
+
   if (!token_service_)
     token_service_ = base::MakeUnique<AccessTokenService>(this);
-  token_service_->RequestToken(type);
+  token_service_->RequestToken(type, callback_id);
 }
 
 void PrintPreviewHandler::HandleManageCloudPrint(
@@ -1318,11 +1336,21 @@ void PrintPreviewHandler::ClosePreviewDialog() {
   print_preview_ui()->OnClosePrintPreviewDialog();
 }
 
-void PrintPreviewHandler::SendAccessToken(const std::string& type,
+void PrintPreviewHandler::SendAccessToken(const std::string& callback_id,
                                           const std::string& access_token) {
   VLOG(1) << "Get getAccessToken finished";
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "onDidGetAccessToken", base::Value(type), base::Value(access_token));
+  base::DictionaryValue response;
+  response.SetBoolean("completed", true);
+  response.SetString("accessToken", access_token);
+  ResolveJavascriptCallback(base::Value(callback_id), response);
+}
+
+void PrintPreviewHandler::SendRequestInProgress(
+    const std::string& callback_id) {
+  base::DictionaryValue response;
+  response.SetBoolean("completed", false);
+  response.SetString("accessToken", "");
+  ResolveJavascriptCallback(base::Value(callback_id), response);
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
@@ -1783,16 +1811,13 @@ void PrintPreviewHandler::OnGotPrintersForExtension(
 }
 
 void PrintPreviewHandler::OnGotExtensionPrinterInfo(
-    const std::string& printer_id,
+    const std::string& callback_id,
     const base::DictionaryValue& printer_info) {
   if (printer_info.empty()) {
-    web_ui()->CallJavascriptFunctionUnsafe("failedToResolveProvisionalPrinter",
-                                           base::Value(printer_id));
+    RejectJavascriptCallback(base::Value(callback_id), base::Value());
     return;
   }
-
-  web_ui()->CallJavascriptFunctionUnsafe("onProvisionalPrinterResolved",
-                                         base::Value(printer_id), printer_info);
+  ResolveJavascriptCallback(base::Value(callback_id), printer_info);
 }
 
 void PrintPreviewHandler::OnGotExtensionPrinterCapabilities(