Print Preview: Remembering last used printer.

chrome/browser/ui/webui/print_preview_handler.cc

 // Copyright (c) 2011 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_handler.h"
 
 #include <string>
 
 #include "base/i18n/file_util_icu.h"
 #include "base/json/json_reader.h"
@@ skipping 150 matching lines @@
   PrintSystemTaskProxy(const base::WeakPtr<PrintPreviewHandler>& handler,
                        printing::PrintBackend* print_backend,
                        bool has_logged_printers_count)
       : handler_(handler),
         print_backend_(print_backend),
         has_logged_printers_count_(has_logged_printers_count) {
   }
 
   void GetDefaultPrinter() {
     VLOG(1) << "Get default printer start";
-    StringValue* default_printer =
-        new StringValue(print_backend_->GetDefaultPrinterName());
-    VLOG(1) << "Get default printer finished, found: " << default_printer;
+    StringValue* default_printer = NULL;
+    if (PrintPreviewHandler::last_used_printer_ == NULL) {
+      default_printer = new StringValue(
+          print_backend_->GetDefaultPrinterName());
+    } else {
+      default_printer = new StringValue(
+          *PrintPreviewHandler::last_used_printer_);
+    }
+    std::string default_printer_string;
+    default_printer->GetAsString(&default_printer_string);
+    VLOG(1) << "Get default printer finished, found: "
+            << default_printer_string;
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &PrintSystemTaskProxy::SendDefaultPrinter,
                           default_printer));
   }
 
   void SendDefaultPrinter(StringValue* default_printer) {
     if (handler_)
       handler_->SendDefaultPrinter(*default_printer);
     delete default_printer;
   }
 
   void EnumeratePrinters() {
     VLOG(1) << "Enumerate printers start";
     ListValue* printers = new ListValue;
-    int default_printer_index = -1;
 
     printing::PrinterList printer_list;
     print_backend_->EnumeratePrinters(&printer_list);
 
     if (!has_logged_printers_count_) {
       // Record the total number of printers.
       UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters",
                            printer_list.size());
     }
 
     int i = 0;
     for (printing::PrinterList::iterator iter = printer_list.begin();
          iter != printer_list.end(); ++iter, ++i) {
       DictionaryValue* printer_info = new DictionaryValue;
       std::string printerName;
   #if defined(OS_MACOSX)
       // On Mac, |iter->printer_description| specifies the printer name and
       // |iter->printer_name| specifies the device name / printer queue name.
       printerName = iter->printer_description;
   #else
       printerName = iter->printer_name;
   #endif
       printer_info->SetString(printing::kSettingPrinterName, printerName);
       printer_info->SetString(printing::kSettingDeviceName, iter->printer_name);
       printers->Append(printer_info);
-      if (iter->is_default)
-        default_printer_index = i;
     }
     VLOG(1) << "Enumerate printers finished, found " << i << " printers";
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &PrintSystemTaskProxy::SendPrinterList,
-                          printers,
-                          new FundamentalValue(default_printer_index)));
+                          printers));
   }
 
-  void SendPrinterList(ListValue* printers,
-                       FundamentalValue* default_printer_index) {
+  void SendPrinterList(ListValue* printers) {
     if (handler_)
-      handler_->SendPrinterList(*printers, *default_printer_index);
+      handler_->SendPrinterList(*printers);
     delete printers;
-    delete default_printer_index;
   }
 
   void GetPrinterCapabilities(const std::string& printer_name) {
     VLOG(1) << "Get printer capabilities start for " << printer_name;
     printing::PrinterCapsAndDefaults printer_info;
     bool supports_color = true;
     if (!print_backend_->GetPrinterCapsAndDefaults(printer_name,
                                                    &printer_info)) {
       return;
     }
@@ skipping 85 matching lines @@
  private:
   // The metafile holding the PDF data.
   scoped_ptr<printing::Metafile> metafile_;
 
   // The absolute path where the file will be saved.
   FilePath path_;
 };
 
 // static
 FilePath* PrintPreviewHandler::last_saved_path_ = NULL;
+std::string* PrintPreviewHandler::last_used_printer_ = NULL;
 
 PrintPreviewHandler::PrintPreviewHandler()
     : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
       regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
       has_logged_printers_count_(false) {
   ReportUserActionHistogram(PREVIEW_STARTED);
 }
 
@@ skipping 82 matching lines @@
   TabContents* initiator_tab = GetInitiatorTab();
   if (initiator_tab) {
     RenderViewHost* rvh = initiator_tab->render_view_host();
     rvh->Send(new PrintMsg_ResetScriptedPrintCount(rvh->routing_id()));
   }
 
   scoped_ptr<DictionaryValue> settings(GetSettingsDictionary(args));
   if (!settings.get())
     return;
 
+  // Initializing last_used_printer_ if it is not already initialized.
+  if (!last_used_printer_)
+    last_used_printer_ = new std::string();
+  // Storing last used printer.
+  settings->GetString("deviceName", last_used_printer_);
+
   bool print_to_pdf = false;
   settings->GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf);
 
   TabContentsWrapper* preview_tab_wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(preview_tab());
 
   if (print_to_pdf) {
     ReportUserActionHistogram(PRINT_TO_PDF);
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToPDF",
                          GetPageCountFromSettingsDictionary(*settings));
@@ skipping 99 matching lines @@
   VLOG(1) << "Get printer capabilities finished";
   web_ui_->CallJavascriptFunction("updateWithPrinterCapabilities",
                                   settings_info);
 }
 
 void PrintPreviewHandler::SendDefaultPrinter(
     const StringValue& default_printer) {
   web_ui_->CallJavascriptFunction("setDefaultPrinter", default_printer);
 }
 
-void PrintPreviewHandler::SendPrinterList(
-    const ListValue& printers,
-    const FundamentalValue& default_printer_index) {
-  web_ui_->CallJavascriptFunction("setPrinters", printers,
-                                  default_printer_index);
+void PrintPreviewHandler::SendPrinterList(const ListValue& printers) {
+  web_ui_->CallJavascriptFunction("setPrinters", printers);
 }
 
 TabContents* PrintPreviewHandler::GetInitiatorTab() {
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
   if (!tab_controller)
     return NULL;
   return tab_controller->GetInitiatorTab(preview_tab());
 }
 
@@ skipping 54 matching lines @@
   metafile->InitFromData(static_cast<const void*>(data->front()), data->size());
 
   // Updating last_saved_path_ to the newly selected folder.
   *last_saved_path_ = path.DirName();
 
   PrintToPdfTask* task = new PrintToPdfTask(metafile, path);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, task);
 
   ActivateInitiatorTabAndClosePreviewTab();
 }