Print Preview: Change print to cr.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 184 matching lines @@
 // Dictionary field holding the default destination selection rules.
 const char kDefaultDestinationSelectionRules[] =
     "defaultDestinationSelectionRules";
 
 // Id of the predefined PDF printer.
 const char kLocalPdfPrinterId[] = "Save as PDF";
 
 // Timeout for searching for privet printers, in seconds.
 const int kPrivetTimeoutSec = 5;
 
-// Get the print job settings dictionary from |args|. The caller takes
-// ownership of the returned DictionaryValue. Returns NULL on failure.
+// Get the print job settings dictionary from |json_str|. Returns NULL on
+// failure.
 std::unique_ptr<base::DictionaryValue> GetSettingsDictionary(
-    const base::ListValue* args) {
-  std::string json_str;
-  if (!args->GetString(0, &json_str)) {
-    NOTREACHED() << "Could not read JSON argument";
-    return NULL;
-  }
+    const std::string& json_str) {
   if (json_str.empty()) {
     NOTREACHED() << "Empty print job settings";
     return NULL;
   }
   std::unique_ptr<base::DictionaryValue> settings =
       base::DictionaryValue::From(base::JSONReader::Read(json_str));
   if (!settings) {
     NOTREACHED() << "Print job settings must be a dictionary.";
     return NULL;
   }
@@ skipping 457 matching lines @@
 
   AllowJavascript();
 
   if (!PrivetPrintingEnabled()) {
     RejectJavascriptCallback(base::Value(callback_id), base::Value());
   }
 #if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
   using local_discovery::ServiceDiscoverySharedClient;
   scoped_refptr<ServiceDiscoverySharedClient> service_discovery =
       ServiceDiscoverySharedClient::GetInstance();
-  DCHECK(privet_callback_id_.empty());
-  privet_callback_id_ = callback_id;
+  DCHECK(privet_search_callback_id_.empty());
+  privet_search_callback_id_ = callback_id;
   StartPrivetLister(service_discovery);
 #endif
 }
 
 void PrintPreviewHandler::StopPrivetLister() {
 #if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
   privet_lister_timer_.reset();
   if (PrivetPrintingEnabled() && printer_lister_) {
     printer_lister_->Stop();
   }
-  ResolveJavascriptCallback(base::Value(privet_callback_id_), base::Value());
-  privet_callback_id_ = "";
+  ResolveJavascriptCallback(base::Value(privet_search_callback_id_),
+                            base::Value());
+  privet_search_callback_id_.clear();
 #endif
 }
 
 void PrintPreviewHandler::HandleGetPrivetPrinterCapabilities(
     const base::ListValue* args) {
   AllowJavascript();
 
   std::string callback_id;
   std::string printer_name;
   if (!args->GetString(0, &callback_id) || !args->GetString(1, &printer_name) ||
@@ skipping 54 matching lines @@
 
   EnsureExtensionPrinterHandlerSet();
   extension_printer_handler_->StartGetCapability(
       printer_name,
       base::Bind(&PrintPreviewHandler::OnGotExtensionPrinterCapabilities,
                  weak_factory_.GetWeakPtr(), callback_id));
 }
 
 void PrintPreviewHandler::HandleGetPreview(const base::ListValue* args) {
   DCHECK_EQ(2U, args->GetSize());
-  std::unique_ptr<base::DictionaryValue> settings = GetSettingsDictionary(args);
+  std::string json_str;
+  if (!args->GetString(0, &json_str))
+    return;
+  std::unique_ptr<base::DictionaryValue> settings =
+      GetSettingsDictionary(json_str);
   if (!settings)
     return;
   int request_id = -1;
   if (!settings->GetInteger(printing::kPreviewRequestID, &request_id))
     return;
 
   print_preview_ui()->OnPrintPreviewRequest(request_id);
   // Add an additional key in order to identify |print_preview_ui| later on
   // when calling PrintPreviewUI::GetCurrentPrintPreviewStatus() on the IO
   // thread.
@@ skipping 65 matching lines @@
 }
 
 void PrintPreviewHandler::HandlePrint(const base::ListValue* args) {
   ReportStats();
 
   // Record the number of times the user requests to regenerate preview data
   // before printing.
   UMA_HISTOGRAM_COUNTS("PrintPreview.RegeneratePreviewRequest.BeforePrint",
                        regenerate_preview_request_count_);
 
-  std::unique_ptr<base::DictionaryValue> settings = GetSettingsDictionary(args);
+  AllowJavascript();
+
+  std::string callback_id;
+  CHECK(args->GetString(0, &callback_id));
+  CHECK(!callback_id.empty());
+  std::string json_str;
+  if (!args->GetString(1, &json_str))
+    RejectJavascriptCallback(base::Value(callback_id), base::Value(-1));

[Lei Zhang, 2017/07/11 05:11:10]

Wait, don't we need to return after a failure like this?

[rbpotter, 2017/07/11 16:35:50]

Yes for the case below. Should probably just crash here. The ticket
should never be empty unless something is wrong with the print preview
JS code. https://codereview.chromium.org/2980603002/

+
+  std::unique_ptr<base::DictionaryValue> settings =
+      GetSettingsDictionary(json_str);
   if (!settings)
-    return;
+    RejectJavascriptCallback(base::Value(callback_id), base::Value(-1));
 
   ReportPrintSettingsStats(*settings);
 
   // Report whether the user printed a PDF or an HTML document.
   ReportPrintDocumentTypeHistogram(print_preview_ui()->source_is_modifiable() ?
                                    HTML_DOCUMENT : PDF_DOCUMENT);
 
   bool print_to_pdf = false;
   bool is_cloud_printer = false;
   bool print_with_privet = false;
@@ skipping 11 matching lines @@
                          &print_with_extension);
     is_cloud_printer = settings->HasKey(printing::kSettingCloudPrintId);
   }
 
   int page_count = 0;
   settings->GetInteger(printing::kSettingPreviewPageCount, &page_count);
 
   if (print_to_pdf) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToPDF", page_count);
     ReportUserActionHistogram(PRINT_TO_PDF);
+    DCHECK(pdf_callback_id_.empty());
+    pdf_callback_id_ = callback_id;
     PrintToPdf();
     return;
   }
 
 #if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
   if (print_with_privet && PrivetPrintingEnabled()) {
     std::string printer_name;
     std::string print_ticket;
     std::string capabilities;
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintWithPrivet", page_count);
     ReportUserActionHistogram(PRINT_WITH_PRIVET);
 
     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();
-      FireWebUIListener("print-failed", base::Value(-1));
+      RejectJavascriptCallback(base::Value(callback_id), base::Value(-1));
       return;
     }
 
-    PrintToPrivetPrinter(
-        printer_name, print_ticket, capabilities, gfx::Size(width, height));
+    DCHECK(privet_print_callback_id_.empty());
+    privet_print_callback_id_ = callback_id;
+    PrintToPrivetPrinter(callback_id, printer_name, print_ticket, capabilities,
+                         gfx::Size(width, height));
     return;
   }
 #endif
 
   if (print_with_extension) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintWithExtension",
                          page_count);
     ReportUserActionHistogram(PRINT_WITH_EXTENSION);
 
     std::string destination_id;
     std::string print_ticket;
     std::string capabilities;
     int width = 0;
     int height = 0;
     if (!settings->GetString(printing::kSettingDeviceName, &destination_id) ||
         !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();
-      OnExtensionPrintResult(false, "FAILED");
+      RejectJavascriptCallback(base::Value(callback_id), base::Value("FAILED"));
       return;
     }
 
     base::string16 title;
     scoped_refptr<base::RefCountedBytes> data;
     if (!GetPreviewDataAndTitle(&data, &title)) {
       LOG(ERROR) << "Nothing to print; no preview available.";
-      OnExtensionPrintResult(false, "NO_DATA");
+      RejectJavascriptCallback(base::Value(callback_id),
+                               base::Value("NO_DATA"));
       return;
     }
 
     EnsureExtensionPrinterHandlerSet();
     extension_printer_handler_->StartPrint(
         destination_id, capabilities, title, print_ticket,
         gfx::Size(width, height), data,
         base::Bind(&PrintPreviewHandler::OnExtensionPrintResult,
-                   weak_factory_.GetWeakPtr()));
+                   weak_factory_.GetWeakPtr(), callback_id));
     return;
   }
 
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
   if (!GetPreviewDataAndTitle(&data, &title)) {
     // Nothing to print, no preview available.
+    RejectJavascriptCallback(base::Value(callback_id), base::Value());
     return;
   }
 
   if (is_cloud_printer) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToCloudPrint",
                          page_count);
     ReportUserActionHistogram(PRINT_WITH_CLOUD_PRINT);
-    SendCloudPrintJob(data.get());
+    SendCloudPrintJob(callback_id, data.get());
     return;
   }
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
   bool system_dialog = false;
   settings->GetBoolean(printing::kSettingShowSystemDialog, &system_dialog);
   if (system_dialog) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.SystemDialog", page_count);
     ReportUserActionHistogram(FALLBACK_TO_ADVANCED_SETTINGS_DIALOG);
   } else {
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToPrinter", page_count);
     ReportUserActionHistogram(PRINT_TO_PRINTER);
   }
 
-  // This tries to activate the initiator as well, so do not clear the
-  // association with the initiator yet.
-  print_preview_ui()->OnHidePreviewDialog();
-
-  // Grab the current initiator before calling ClearInitiatorDetails() below.
-  // Otherwise calling GetInitiator() later will return the wrong WebContents.
-  // https://crbug.com/407080
   WebContents* initiator = GetInitiator();
   if (initiator) {
     // Save initiator IDs. PrintMsg_PrintForPrintPreview below should cause
     // the renderer to send PrintHostMsg_UpdatePrintSettings and trigger
     // PrintingMessageFilter::OnUpdatePrintSettings(), which needs this info.
     auto* main_render_frame = initiator->GetMainFrame();
     settings->SetInteger(printing::kPreviewInitiatorHostId,
                          main_render_frame->GetProcess()->GetID());
     settings->SetInteger(printing::kPreviewInitiatorRoutingId,
                          main_render_frame->GetRoutingID());
   }
 
-  // Do this so the initiator can open a new print preview dialog, while the
-  // current print preview dialog is still handling its print job.
-  ClearInitiatorDetails();
-
   // Set ID to know whether printing is for preview.
   settings->SetInteger(printing::kPreviewUIID,
                        print_preview_ui()->GetIDForPrintPreviewUI());
   RenderFrameHost* rfh = preview_web_contents()->GetMainFrame();
   rfh->Send(new PrintMsg_PrintForPrintPreview(rfh->GetRoutingID(), *settings));
 
-  // For all other cases above, the preview dialog will stay open until the
-  // printing has finished. Then the dialog closes and PrintPreviewDone() gets
-  // called. In the case below, since the preview dialog will be hidden and
-  // not closed, we need to make this call.
-  if (initiator) {
-    auto* print_view_manager = PrintViewManager::FromWebContents(initiator);
-    print_view_manager->PrintPreviewDone();
-  }
+  // Set this so when print preview sends "hidePreviewDialog" we clear the
+  // initiator and call PrintPreviewDone(). In the cases above, the preview
+  // dialog stays open until printing is finished and we do this when the
+  // dialog is closed. In this case, we set this so that these tasks are
+  // done in HandleHidePreview().
+  printing_started_ = true;
+
+  // This will ultimately try to activate the initiator as well, so do not
+  // clear the association with the initiator until "hidePreviewDialog" is
+  // received from JS.
+  ResolveJavascriptCallback(base::Value(callback_id), base::Value());
+
 #else
   NOTREACHED();
 #endif   // BUILDFLAG(ENABLE_BASIC_PRINTING)
 }
 
 void PrintPreviewHandler::PrintToPdf() {
   if (!print_to_pdf_path_.empty()) {
     // User has already selected a path, no need to show the dialog again.
+    ResolveJavascriptCallback(base::Value(pdf_callback_id_), base::Value());
+    pdf_callback_id_.clear();
     PostPrintToPdfTask();
   } else if (!select_file_dialog_.get() ||
              !select_file_dialog_->IsRunning(platform_util::GetTopLevel(
                  preview_web_contents()->GetNativeView()))) {
     // Pre-populating select file dialog with print job title.
     const base::string16& print_job_title_utf16 =
         print_preview_ui()->initiator_title();
 
 #if defined(OS_WIN)
     base::FilePath::StringType print_job_title(print_job_title_utf16);
 #elif defined(OS_POSIX)
     base::FilePath::StringType print_job_title =
         base::UTF16ToUTF8(print_job_title_utf16);
 #endif
 
     base::i18n::ReplaceIllegalCharactersInPath(&print_job_title, '_');
     base::FilePath default_filename(print_job_title);
     default_filename =
         default_filename.ReplaceExtension(FILE_PATH_LITERAL("pdf"));
 
     base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
     bool prompt_user = !cmdline->HasSwitch(switches::kKioskModePrinting);
     SelectFile(default_filename, prompt_user);
   }
 }
 
 void PrintPreviewHandler::HandleHidePreview(const base::ListValue* /*args*/) {
+  if (printing_started_) {
+    // Printing has started, so clear the initiator so that it can open a new
+    // print preview dialog, while the current print preview dialog is still
+    // handling its print job.
+    WebContents* initiator = GetInitiator();
+    ClearInitiatorDetails();
+
+    // Since the preview dialog will be hidden and not closed, we need to make
+    // this call.
+    if (initiator) {
+      auto* print_view_manager = PrintViewManager::FromWebContents(initiator);
+      print_view_manager->PrintPreviewDone();
+    }
+
+    // Since the initiator is cleared, only want to do this once.
+    printing_started_ = false;
+  }
+
   print_preview_ui()->OnHidePreviewDialog();
 }
 
 void PrintPreviewHandler::HandleCancelPendingPrintRequest(
     const base::ListValue* /*args*/) {
   WebContents* initiator = GetInitiator();
   if (initiator)
     ClearInitiatorDetails();
   chrome::ShowPrintErrorDialog();
 }
@@ skipping 311 matching lines @@
   PrefService* prefs = profile->GetPrefs();
   if (prefs->GetBoolean(prefs::kCloudPrintSubmitEnabled)) {
     base::DictionaryValue settings;
     settings.SetString(kCloudPrintUrl,
                        GURL(cloud_devices::GetCloudPrintURL()).spec());
     settings.SetBoolean(kAppKioskMode, chrome::IsRunningInForcedAppMode());
     web_ui()->CallJavascriptFunctionUnsafe("setUseCloudPrint", settings);
   }
 }
 
-void PrintPreviewHandler::SendCloudPrintJob(const base::RefCountedBytes* data) {
+void PrintPreviewHandler::SendCloudPrintJob(const std::string& callback_id,
+                                            const base::RefCountedBytes* data) {
   // BASE64 encode the job data.
   const base::StringPiece raw_data(reinterpret_cast<const char*>(data->front()),
                                    data->size());
   std::string base64_data;
   base::Base64Encode(raw_data, &base64_data);
-  base::Value data_value(base64_data);
 
-  web_ui()->CallJavascriptFunctionUnsafe("printToCloud", data_value);
+  ResolveJavascriptCallback(base::Value(callback_id), base::Value(base64_data));
 }
 
 WebContents* PrintPreviewHandler::GetInitiator() const {
   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();
 }
 
 void PrintPreviewHandler::SelectFile(const base::FilePath& default_filename,
                                      bool prompt_user) {
   if (prompt_user) {
     ChromeSelectFilePolicy policy(GetInitiator());
     if (!policy.CanOpenSelectFileDialog()) {
       policy.SelectFileDenied();
-      return ClosePreviewDialog();
+      RejectJavascriptCallback(base::Value(pdf_callback_id_), base::Value());
+      pdf_callback_id_.clear();
+      return;
     }
   }
 
   // Get save location from Download Preferences.
   DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
       preview_web_contents()->GetBrowserContext());
   base::FilePath file_path = download_prefs->SaveFilePath();
   printing::StickySettings* sticky_settings = GetStickySettings();
   sticky_settings->SaveInPrefs(Profile::FromBrowserContext(
       preview_web_contents()->GetBrowserContext())->GetPrefs());
@@ skipping 48 matching lines @@
                                        int /* index */,
                                        void* /* params */) {
   // Update downloads location and save sticky settings.
   DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
       preview_web_contents()->GetBrowserContext());
   download_prefs->SetSaveFilePath(path.DirName());
   printing::StickySettings* sticky_settings = GetStickySettings();
   sticky_settings->SaveInPrefs(
       Profile::FromBrowserContext(preview_web_contents()->GetBrowserContext())
           ->GetPrefs());
-  web_ui()->CallJavascriptFunctionUnsafe("fileSelectionCompleted");
+  ResolveJavascriptCallback(base::Value(pdf_callback_id_), base::Value());
+  pdf_callback_id_.clear();
   print_to_pdf_path_ = path;
   PostPrintToPdfTask();
 }
 
 void PrintPreviewHandler::PostPrintToPdfTask() {
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
   if (!GetPreviewDataAndTitle(&data, &title)) {
     NOTREACHED() << "Preview data was checked before file dialog.";
     return;
   }
 
   base::PostTaskWithTraits(
       FROM_HERE, {base::MayBlock(), base::TaskPriority::BACKGROUND},
       base::BindOnce(&PrintToPdfCallback, data, print_to_pdf_path_,
                      pdf_file_saved_closure_));
   print_to_pdf_path_.clear();
   ClosePreviewDialog();
 }
 
 void PrintPreviewHandler::FileSelectionCanceled(void* params) {
-  print_preview_ui()->OnFileSelectionCancelled();
+  RejectJavascriptCallback(base::Value(pdf_callback_id_), base::Value());
+  pdf_callback_id_.clear();
 }
 
 void PrintPreviewHandler::ClearInitiatorDetails() {
   WebContents* initiator = GetInitiator();
   if (!initiator)
     return;
 
   // We no longer require the initiator details. Remove those details associated
   // with the preview dialog to allow the initiator to create another preview
   // dialog.
@@ skipping 67 matching lines @@
       privet_http_client_->CreateCapabilitiesOperation(
           base::Bind(&PrintPreviewHandler::OnPrivetCapabilities,
                      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.
-      FireWebUIListener("print-failed", base::Value(-1));
-    } else {  // Capabilities update failed
-      RejectJavascriptCallback(base::Value(callback_id), base::Value());
-    }
+    RejectJavascriptCallback(base::Value(callback_id), base::Value());
     privet_http_resolution_.reset();
+    if (callback_id == privet_print_callback_id_)
+      privet_print_callback_id_.clear();
     return false;
   }
 
   privet_local_print_operation_.reset();
   privet_capabilities_operation_.reset();
   privet_http_client_ = cloud_print::PrivetV1HTTPClient::CreateDefault(
       std::move(http_client));
 
   privet_http_resolution_.reset();
 
   return true;
 }
 
 void PrintPreviewHandler::PrivetLocalPrintUpdateClient(
+    const std::string& callback_id,
     std::string print_ticket,
     std::string capabilities,
     gfx::Size page_size,
     std::unique_ptr<cloud_print::PrivetHTTPClient> http_client) {
-  if (!PrivetUpdateClient("", std::move(http_client)))
+  if (!PrivetUpdateClient(callback_id, std::move(http_client)))
     return;
 
   StartPrivetLocalPrint(print_ticket, capabilities, page_size);
 }
 
 void PrintPreviewHandler::StartPrivetLocalPrint(const std::string& print_ticket,
                                                 const std::string& capabilities,
                                                 const gfx::Size& page_size) {
   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)) {
-    FireWebUIListener("print-failed", base::Value(-1));
+    RejectJavascriptCallback(base::Value(privet_print_callback_id_),
+                             base::Value(-1));
+    privet_print_callback_id_.clear();
     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 32 matching lines @@
   printer_info_and_caps.SetDictionary("printer", std::move(printer_info));
   std::unique_ptr<base::DictionaryValue> capabilities_copy =
       capabilities->CreateDeepCopy();
   printer_info_and_caps.SetDictionary("capabilities",
                                       std::move(capabilities_copy));
   ResolveJavascriptCallback(base::Value(callback_id), printer_info_and_caps);
 
   privet_capabilities_operation_.reset();
 }
 
-void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& device_name,
+void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& callback_id,
+                                               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))) {
-    FireWebUIListener("print-failed", base::Value(-1));
+                     weak_factory_.GetWeakPtr(), callback_id, ticket,
+                     capabilities, page_size))) {
+    RejectJavascriptCallback(base::Value(privet_print_callback_id_),
+                             base::Value(-1));
+    privet_print_callback_id_.clear();
   }
 }
 
 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;
 
   if (!device_description)
     return false;
 
   privet_http_factory_ =
       cloud_print::PrivetHTTPAsynchronousFactory::CreateInstance(
           Profile::FromWebUI(web_ui())->GetRequestContext());
   privet_http_resolution_ = privet_http_factory_->CreatePrivetHTTP(name);
   privet_http_resolution_->Start(device_description->address, callback);
 
   return true;
 }
 
 void PrintPreviewHandler::OnPrivetPrintingDone(
     const cloud_print::PrivetLocalPrintOperation* print_operation) {
-  ClosePreviewDialog();
+  ResolveJavascriptCallback(base::Value(privet_print_callback_id_),
+                            base::Value());
+  privet_print_callback_id_.clear();
 }
 
 void PrintPreviewHandler::OnPrivetPrintingError(
     const cloud_print::PrivetLocalPrintOperation* print_operation,
     int http_code) {
-  FireWebUIListener("print-failed", base::Value(http_code));
+  RejectJavascriptCallback(base::Value(privet_print_callback_id_),
+                           base::Value(http_code));
+  privet_print_callback_id_.clear();
 }
 
 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 43 matching lines @@
 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);
 }
 
-void PrintPreviewHandler::OnExtensionPrintResult(bool success,
+void PrintPreviewHandler::OnExtensionPrintResult(const std::string& callback_id,
+                                                 bool success,
                                                  const std::string& status) {
   if (success) {
-    ClosePreviewDialog();
+    ResolveJavascriptCallback(base::Value(callback_id), base::Value());
     return;
   }
-  FireWebUIListener("print-failed", base::Value(status));
+  RejectJavascriptCallback(base::Value(callback_id), 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;
 }