Print Preview: Remove global onPrivetPrintFailed

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 899 matching lines @@
 
     int width = 0;
     int height = 0;
     if (!settings->GetString(printing::kSettingDeviceName, &printer_name) ||
         !settings->GetString(printing::kSettingTicket, &print_ticket) ||
         !settings->GetString(printing::kSettingCapabilities, &capabilities) ||
         !settings->GetInteger(printing::kSettingPageWidth, &width) ||
         !settings->GetInteger(printing::kSettingPageHeight, &height) ||
         width <= 0 || height <= 0) {
       NOTREACHED();
-      base::Value http_code_value(-1);
-      web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                             http_code_value);
+      FireWebUIListener("print-failed", base::Value(-1));
       return;
     }
 
     PrintToPrivetPrinter(
         printer_name, print_ticket, capabilities, gfx::Size(width, height));
     return;
   }
 #endif
 
   if (print_with_extension) {
@@ skipping 668 matching lines @@
                      weak_factory_.GetWeakPtr(), callback_id));
   privet_capabilities_operation_->Start();
 }
 
 bool PrintPreviewHandler::PrivetUpdateClient(
     const std::string& callback_id,
     std::unique_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!http_client) {
     if (callback_id.empty()) {
       // This was an attempt to print to a privet printer and has failed.
-      base::Value http_code_value(-1);
-      web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                             http_code_value);
+      FireWebUIListener("print-failed", base::Value(-1));
     } else {  // Capabilities update failed
       RejectJavascriptCallback(base::Value(callback_id), base::Value());
     }
     privet_http_resolution_.reset();
     return false;
   }
 
   privet_local_print_operation_.reset();
   privet_capabilities_operation_.reset();
   privet_http_client_ = cloud_print::PrivetV1HTTPClient::CreateDefault(
@@ skipping 21 matching lines @@
   privet_local_print_operation_ =
       privet_http_client_->CreateLocalPrintOperation(this);
 
   privet_local_print_operation_->SetTicket(print_ticket);
   privet_local_print_operation_->SetCapabilities(capabilities);
 
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
 
   if (!GetPreviewDataAndTitle(&data, &title)) {
-    base::Value http_code_value(-1);
-    web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                           http_code_value);
+    FireWebUIListener("print-failed", base::Value(-1));
     return;
   }
 
   privet_local_print_operation_->SetJobname(base::UTF16ToUTF8(title));
   privet_local_print_operation_->SetPageSize(page_size);
   privet_local_print_operation_->SetData(data.get());
 
   Profile* profile = Profile::FromWebUI(web_ui());
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfileIfExists(profile);
@@ skipping 41 matching lines @@
 
 void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& device_name,
                                                const std::string& ticket,
                                                const std::string& capabilities,
                                                const gfx::Size& page_size) {
   if (!CreatePrivetHTTP(
           device_name,
           base::Bind(&PrintPreviewHandler::PrivetLocalPrintUpdateClient,
                      weak_factory_.GetWeakPtr(), ticket, capabilities,
                      page_size))) {
-    base::Value http_code_value(-1);
-    web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                           http_code_value);
+    FireWebUIListener("print-failed", base::Value(-1));
   }
 }
 
 bool PrintPreviewHandler::CreatePrivetHTTP(
     const std::string& name,
     const cloud_print::PrivetHTTPAsynchronousFactory::ResultCallback&
         callback) {
   const cloud_print::DeviceDescription* device_description =
       printer_lister_ ? printer_lister_->GetDeviceDescription(name) : NULL;
 
@@ skipping 10 matching lines @@
 }
 
 void PrintPreviewHandler::OnPrivetPrintingDone(
     const cloud_print::PrivetLocalPrintOperation* print_operation) {
   ClosePreviewDialog();
 }
 
 void PrintPreviewHandler::OnPrivetPrintingError(
     const cloud_print::PrivetLocalPrintOperation* print_operation,
     int http_code) {
-  base::Value http_code_value(http_code);
-  web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                         http_code_value);
+  FireWebUIListener("print-failed", base::Value(http_code));
 }
 
 void PrintPreviewHandler::FillPrinterDescription(
     const std::string& name,
     const cloud_print::DeviceDescription& description,
     bool has_local_printing,
     base::DictionaryValue* printer_value) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   printer_value->SetString("serviceName", name);
@@ skipping 49 matching lines @@
   }
   ResolveJavascriptCallback(base::Value(callback_id), capabilities);
 }
 
 void PrintPreviewHandler::OnExtensionPrintResult(bool success,
                                                  const std::string& status) {
   if (success) {
     ClosePreviewDialog();
     return;
   }
-
-  // TODO(tbarzic): This function works for extension printers case too, but it
-  // should be renamed to something more generic.
-  web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
-                                         base::Value(status));
+  FireWebUIListener("print-failed", base::Value(status));
 }
 
 void PrintPreviewHandler::RegisterForGaiaCookieChanges() {
   DCHECK(!gaia_cookie_manager_service_);
   Profile* profile = Profile::FromWebUI(web_ui());
   if (switches::IsAccountConsistencyMirrorEnabled() &&
       !profile->IsOffTheRecord()) {
     gaia_cookie_manager_service_ =
         GaiaCookieManagerServiceFactory::GetForProfile(profile);
     if (gaia_cookie_manager_service_)
       gaia_cookie_manager_service_->AddObserver(this);
   }
 }
 
 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;
 }