Change getAccessToken and getExtensionPrinterAccess to sendWithPromise

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

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 #include <stddef.h>
 
 #include <map>
@@ skipping 458 matching lines @@
 }  // namespace
 
 class PrintPreviewHandler::AccessTokenService
     : public OAuth2TokenService::Consumer {
  public:
   explicit AccessTokenService(PrintPreviewHandler* handler)
       : OAuth2TokenService::Consumer("print_preview"),
         handler_(handler) {
   }
 
-  void RequestToken(const std::string& type) {
+  void RequestToken(const std::string& type, const std::string& callback_id) {
     if (requests_.find(type) != requests_.end())
-      return;  // Already in progress.
+      return;  // Should never happen, see cloud_print_interface.js
 
     OAuth2TokenService* service = NULL;
     std::string account_id;
     if (type == "profile") {
       Profile* profile = Profile::FromWebUI(handler_->web_ui());
       if (profile) {
         ProfileOAuth2TokenService* token_service =
             ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
         SigninManagerBase* signin_manager =
             SigninManagerFactory::GetInstance()->GetForProfile(profile);
         account_id = signin_manager->GetAuthenticatedAccountId();
         service = token_service;
       }
     } else if (type == "device") {
 #if defined(OS_CHROMEOS)
       chromeos::DeviceOAuth2TokenService* token_service =
           chromeos::DeviceOAuth2TokenServiceFactory::Get();
       account_id = token_service->GetRobotAccountId();
       service = token_service;
 #endif
     }
 
     if (service) {
       OAuth2TokenService::ScopeSet oauth_scopes;
       oauth_scopes.insert(cloud_devices::kCloudPrintAuthScope);
       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;
       }
     }
     NOTREACHED();
   }
 
   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);
 };
 
 PrintPreviewHandler::PrintPreviewHandler()
     : regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       manage_cloud_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
@@ skipping 186 matching lines @@
   // Make sure all in progress requests are canceled before new printer search
   // starts.
   extension_printer_handler_->Reset();
   extension_printer_handler_->StartGetPrinters(
       base::Bind(&PrintPreviewHandler::OnGotPrintersForExtension,
                  weak_factory_.GetWeakPtr(), callback_id));
 }
 
 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) && !callback_id.empty();
   DCHECK(ok);
 
+  AllowJavascript();
   EnsureExtensionPrinterHandlerSet();
   extension_printer_handler_->StartGrantPrinterAccess(
       printer_id, base::Bind(&PrintPreviewHandler::OnGotExtensionPrinterInfo,
-                             weak_factory_.GetWeakPtr(), printer_id));
+                             weak_factory_.GetWeakPtr(), callback_id));
 }
 
 void PrintPreviewHandler::HandleGetExtensionPrinterCapabilities(
     const base::ListValue* args) {
   AllowJavascript();
 
   std::string callback_id;
   std::string printer_name;
   if (!args->GetString(0, &callback_id) || !args->GetString(1, &printer_name) ||
       callback_id.empty() || printer_name.empty()) {
@@ skipping 381 matching lines @@
       preview_web_contents()->GetBrowserContext());
   chrome::ScopedTabbedBrowserDisplayer displayer(profile);
   print_dialog_cloud::CreateCloudPrintSigninTab(
       displayer.browser(),
       add_account,
       base::Bind(&PrintPreviewHandler::OnSigninComplete,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleGetAccessToken(const base::ListValue* args) {
+  std::string callback_id;
   std::string type;
-  if (!args->GetString(0, &type))
-    return;
+
+  bool ok = args->GetString(0, &callback_id) && args->GetString(1, &type) &&
+            !callback_id.empty();
+  DCHECK(ok);
+
+  AllowJavascript();
   if (!token_service_)
     token_service_ = base::MakeUnique<AccessTokenService>(this);
-  token_service_->RequestToken(type);
+  token_service_->RequestToken(type, callback_id);
 }
 
 void PrintPreviewHandler::HandleManageCloudPrint(
     const base::ListValue* args) {
   ++manage_cloud_printers_dialog_request_count_;
   GURL manage_url(cloud_devices::GetCloudPrintRelativeURL("manage.html"));
   std::string user;
   if (!args->GetString(0, &user))
     return;
   if (!user.empty())
@@ skipping 138 matching lines @@
 
   if (print_preview_ui()->source_is_modifiable())
     GetNumberFormatAndMeasurementSystem(&initial_settings);
   ResolveJavascriptCallback(base::Value(callback_id), initial_settings);
 }
 
 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));
+  ResolveJavascriptCallback(base::Value(callback_id),
+                            base::Value(access_token));
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
     const std::string& callback_id,
     const std::string& printer_name,
     std::unique_ptr<base::DictionaryValue> settings_info) {
   // Check that |settings_info| is valid.
   if (settings_info && settings_info->Get("capabilities", nullptr)) {
     VLOG(1) << "Get printer capabilities finished";
     ResolveJavascriptCallback(base::Value(callback_id), *settings_info);
@@ skipping 440 matching lines @@
     bool done) {
   AllowJavascript();
 
   FireWebUIListener("extension-printers-added", printers);
   if (done) {
     ResolveJavascriptCallback(base::Value(callback_id), base::Value());
   }
 }
 
 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(
     const std::string& callback_id,
     const base::DictionaryValue& capabilities) {
   if (capabilities.empty()) {
     RejectJavascriptCallback(base::Value(callback_id), base::Value());
     return;
   }
   ResolveJavascriptCallback(base::Value(callback_id), capabilities);
@@ skipping 22 matching lines @@
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }