Print Preview: Finish removing global Javascript functions.

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 1155 matching lines @@
                              base::Value(printer_name));
     return;
   }
 
   printer_backend_proxy()->ConfigurePrinterAndFetchCapabilities(
       printer_name,
       base::Bind(&PrintPreviewHandler::SendPrinterSetup,
                  weak_factory_.GetWeakPtr(), callback_id, printer_name));
 }
 
-void PrintPreviewHandler::OnSigninComplete() {
-  if (print_preview_ui())
-    print_preview_ui()->OnReloadPrintersList();
+void PrintPreviewHandler::OnSigninComplete(const std::string& callback_id) {
+  ResolveJavascriptCallback(base::Value(callback_id), base::Value());
 }
 
 void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
+  std::string callback_id;
   bool add_account = false;
-  bool success = args->GetBoolean(0, &add_account);
-  DCHECK(success);
+  bool success = args->GetString(0, &callback_id);

[dpapad, 2017/07/07 21:12:41]

Nit (optional): Do we need the temp |success| variable?

CHECK(args->GetString(0, &callback_id));
...
CHECK(args->GetBoolean(1, &add_account));

[rbpotter, 2017/07/07 23:58:39]

Done.

+  CHECK(success);
+  CHECK(!callback_id.empty());
+  success = args->GetBoolean(1, &add_account);
+  CHECK(success);
 
   Profile* profile = Profile::FromBrowserContext(
       preview_web_contents()->GetBrowserContext());
   chrome::ScopedTabbedBrowserDisplayer displayer(profile);
   print_dialog_cloud::CreateCloudPrintSigninTab(
-      displayer.browser(),
-      add_account,
+      displayer.browser(), add_account,
       base::Bind(&PrintPreviewHandler::OnSigninComplete,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), callback_id));
 }
 
 void PrintPreviewHandler::HandleGetAccessToken(const base::ListValue* args) {
   std::string callback_id;
   std::string type;
 
   bool ok = args->GetString(0, &callback_id) && args->GetString(1, &type) &&
             !callback_id.empty();
   DCHECK(ok);
 
@@ skipping 249 matching lines @@
   printing::PrintPreviewDialogController* dialog_controller =
       printing::PrintPreviewDialogController::GetInstance();
   if (!dialog_controller)
     return NULL;
   return dialog_controller->GetInitiator(preview_web_contents());
 }
 
 void PrintPreviewHandler::OnAddAccountToCookieCompleted(
     const std::string& account_id,
     const GoogleServiceAuthError& error) {
-  OnSigninComplete();
+  FireWebUIListener("reload-printer-list");
 }
 
 void PrintPreviewHandler::SelectFile(const base::FilePath& default_filename,
                                      bool prompt_user) {
   if (prompt_user) {
     ChromeSelectFilePolicy policy(GetInitiator());
     if (!policy.CanOpenSelectFileDialog()) {
       policy.SelectFileDenied();
       RejectJavascriptCallback(base::Value(pdf_callback_id_), base::Value());
       pdf_callback_id_.clear();
@@ skipping 76 matching lines @@
   preview_callbacks_.pop();
 }
 
 void PrintPreviewHandler::OnInvalidPrinterSettings() {
   CHECK(!preview_callbacks_.empty());
   RejectJavascriptCallback(base::Value(preview_callbacks_.front()),
                            base::Value("SETTINGS_INVALID"));
   preview_callbacks_.pop();
 }
 
+void PrintPreviewHandler::SendPrintPresetOptions(bool disable_scaling,
+                                                 int copies,
+                                                 int duplex) {
+  FireWebUIListener("print-preset-options", base::Value(disable_scaling),
+                    base::Value(copies), base::Value(duplex));
+}
+
+void PrintPreviewHandler::SendPageCountReady(int page_count,
+                                             int request_id,
+                                             int fit_to_page_scaling) {
+  FireWebUIListener("page-count-ready", base::Value(page_count),
+                    base::Value(request_id), base::Value(fit_to_page_scaling));
+}
+
+void PrintPreviewHandler::SendPageLayoutReady(
+    const base::DictionaryValue& layout,
+    bool has_custom_page_size_style) {
+  FireWebUIListener("page-layout-ready", layout,
+                    base::Value(has_custom_page_size_style));
+}
+
+void PrintPreviewHandler::SendPagePreviewReady(int page_index,
+                                               int preview_uid,
+                                               int preview_response_id) {
+  FireWebUIListener("page-preview-ready", base::Value(page_index),
+                    base::Value(preview_uid), base::Value(preview_response_id));
+}
+
 void PrintPreviewHandler::OnPrintPreviewCancelled() {
   CHECK(!preview_callbacks_.empty());
   RejectJavascriptCallback(base::Value(preview_callbacks_.front()),
                            base::Value("CANCELLED"));
   preview_callbacks_.pop();
 }
 
 #if BUILDFLAG(ENABLE_BASIC_PRINT_DIALOG)
 void PrintPreviewHandler::ShowSystemDialog() {
   HandleShowSystemDialog(NULL);
@@ skipping 352 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;
 }