Revert 110035 - Print Preview: Making margin selection sticky (part 2/2)

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 <ctype.h>
 
 #include <string>
 #include <vector>
@@ skipping 32 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/print_messages.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "printing/backend/print_backend.h"
 #include "printing/metafile.h"
 #include "printing/metafile_impl.h"
 #include "printing/page_range.h"
-#include "printing/page_size_margins.h"
 #include "printing/print_settings.h"
 #include "unicode/ulocdata.h"
 
 #if !defined(OS_CHROMEOS)
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
 using content::BrowserThread;
 
@@ skipping 26 matching lines @@
 void ReportUserActionHistogram(enum UserActionBuckets event) {
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.UserAction", event,
                             USERACTION_BUCKET_BOUNDARY);
 }
 
 void ReportPrintSettingHistogram(enum PrintSettingsBuckets setting) {
   UMA_HISTOGRAM_ENUMERATION("PrintPreview.PrintSettings", setting,
                             PRINT_SETTINGS_BUCKET_BOUNDARY);
 }
 
-// Name of a dictionary fielad holdong cloud print related data;
-const char kCloudPrintData[] = "cloudPrintData";
-// Name of a dictionary field holding the initiator tab title.
-const char kInitiatorTabTitle[] = "initiatorTabTitle";
-// Name of a dictionary field holding the measurement system according to the
-// locale.
-const char kMeasurementSystem[] = "measurementSystem";
-// Name of a dictionary field holding the number format according to the locale.
-const char kNumberFormat[] = "numberFormat";
-
-
 // Get the print job settings dictionary from |args|. The caller takes
 // ownership of the returned DictionaryValue. Returns NULL on failure.
 DictionaryValue* GetSettingsDictionary(const ListValue* args) {
   std::string json_str;
   if (!args->GetString(0, &json_str)) {
     NOTREACHED() << "Could not read JSON argument";
     return NULL;
   }
   if (json_str.empty()) {
     NOTREACHED() << "Empty print job settings";
@@ skipping 90 matching lines @@
 };
 
 // static
 FilePath* PrintPreviewHandler::last_saved_path_ = NULL;
 std::string* PrintPreviewHandler::last_used_printer_cloud_print_data_ = NULL;
 std::string* PrintPreviewHandler::last_used_printer_name_ = NULL;
 printing::ColorModels PrintPreviewHandler::last_used_color_model_ =
     printing::UNKNOWN_COLOR_MODEL;
 printing::MarginType PrintPreviewHandler::last_used_margins_type_ =
     printing::DEFAULT_MARGINS;
-printing::PageSizeMargins*
-    PrintPreviewHandler::last_used_page_size_margins_ = 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);
 }
 
 PrintPreviewHandler::~PrintPreviewHandler() {
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 }
 
 void PrintPreviewHandler::RegisterMessages() {
+  web_ui_->RegisterMessageCallback("getDefaultPrinter",
+      base::Bind(&PrintPreviewHandler::HandleGetDefaultPrinter,
+                 base::Unretained(this)));
   web_ui_->RegisterMessageCallback("getPrinters",
       base::Bind(&PrintPreviewHandler::HandleGetPrinters,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("getPreview",
       base::Bind(&PrintPreviewHandler::HandleGetPreview,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("print",
       base::Bind(&PrintPreviewHandler::HandlePrint,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("getPrinterCapabilities",
@@ skipping 19 matching lines @@
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("hidePreview",
       base::Bind(&PrintPreviewHandler::HandleHidePreview,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("cancelPendingPrintRequest",
       base::Bind(&PrintPreviewHandler::HandleCancelPendingPrintRequest,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("saveLastPrinter",
       base::Bind(&PrintPreviewHandler::HandleSaveLastPrinter,
                  base::Unretained(this)));
-  web_ui_->RegisterMessageCallback("getInitialSettings",
-      base::Bind(&PrintPreviewHandler::HandleGetInitialSettings,
+  web_ui_->RegisterMessageCallback("getInitiatorTabTitle",
+      base::Bind(&PrintPreviewHandler::HandleGetInitiatorTabTitle,
                  base::Unretained(this)));
+  web_ui_->RegisterMessageCallback("getNumberFormatAndMeasurementSystem",
+      base::Bind(
+          &PrintPreviewHandler::HandleGetNumberFormatAndMeasurementSystem,
+          base::Unretained(this)));
 }
 
 TabContentsWrapper* PrintPreviewHandler::preview_tab_wrapper() const {
   return TabContentsWrapper::GetCurrentWrapperForContents(preview_tab());
 }
 TabContents* PrintPreviewHandler::preview_tab() const {
   return web_ui_->tab_contents();
 }
 
+void PrintPreviewHandler::HandleGetDefaultPrinter(const ListValue* /*args*/) {
+  scoped_refptr<PrintSystemTaskProxy> task =
+      new PrintSystemTaskProxy(AsWeakPtr(),
+                               print_backend_.get(),
+                               has_logged_printers_count_);
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&PrintSystemTaskProxy::GetDefaultPrinter, task.get()));
+}
+
 void PrintPreviewHandler::HandleGetPrinters(const ListValue* /*args*/) {
   scoped_refptr<PrintSystemTaskProxy> task =
       new PrintSystemTaskProxy(AsWeakPtr(),
                                print_backend_.get(),
                                has_logged_printers_count_);
   has_logged_printers_count_ = true;
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&PrintSystemTaskProxy::EnumeratePrinters, task.get()));
@@ skipping 87 matching lines @@
   if (!settings.get())
     return;
 
   // Storing last used color model.
   int color_model;
   if (!settings->GetInteger(printing::kSettingColor, &color_model))
     color_model = printing::GRAY;
   last_used_color_model_ = static_cast<printing::ColorModels>(color_model);
 
   // Storing last used margin settings.
-  bool is_modifiable;
-  settings->GetBoolean(printing::kSettingPreviewModifiable, &is_modifiable);
-  if (is_modifiable) {
-    int margin_type;
-    if (!settings->GetInteger(printing::kSettingMarginsType, &margin_type))
-      margin_type = printing::DEFAULT_MARGINS;
-    last_used_margins_type_ = static_cast<printing::MarginType>(margin_type);
-    if (last_used_margins_type_ == printing::CUSTOM_MARGINS) {
-      if (!last_used_page_size_margins_)
-        last_used_page_size_margins_ = new printing::PageSizeMargins();
-      getCustomMarginsFromJobSettings(*settings, last_used_page_size_margins_);
-    }
-  }
+  int margin_type;
+  if (!settings->GetInteger(printing::kSettingMarginsType, &margin_type))
+    margin_type = printing::DEFAULT_MARGINS;
+  last_used_margins_type_ = static_cast<printing::MarginType>(margin_type);
 
   bool print_to_pdf = false;
   settings->GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf);
 
   settings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
 
   bool is_cloud_printer = settings->HasKey(printing::kSettingCloudPrintId);
   bool is_cloud_dialog = false;
   settings->GetBoolean(printing::kSettingCloudPrintDialog, &is_cloud_dialog);
   if (is_cloud_printer) {
@@ skipping 192 matching lines @@
                        regenerate_preview_request_count_);
 
   ActivateInitiatorTabAndClosePreviewTab();
 }
 
 void PrintPreviewHandler::ReportStats() {
   UMA_HISTOGRAM_COUNTS("PrintPreview.ManagePrinters",
                        manage_printers_dialog_request_count_);
 }
 
-void PrintPreviewHandler::GetNumberFormatAndMeasurementSystem(
-    base::DictionaryValue* settings) {
+void PrintPreviewHandler::HandleGetInitiatorTabTitle(
+    const ListValue* /*args*/) {
+  PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(web_ui_);
+  base::StringValue tab_title(print_preview_ui->initiator_tab_title());
+  web_ui_->CallJavascriptFunction("setInitiatorTabTitle", tab_title);
+}
+
+void PrintPreviewHandler::HandleGetNumberFormatAndMeasurementSystem(
+    const ListValue* /*args*/) {
 
   // Getting the measurement system based on the locale.
   UErrorCode errorCode = U_ZERO_ERROR;
   const char* locale = g_browser_process->GetApplicationLocale().c_str();
-  UMeasurementSystem system = ulocdata_getMeasurementSystem(locale, &errorCode);
-  if (errorCode > U_ZERO_ERROR || system == UMS_LIMIT)
-    system = UMS_SI;
+  UMeasurementSystem measurement_system =
+      ulocdata_getMeasurementSystem(locale, &errorCode);
+  if (errorCode > U_ZERO_ERROR || measurement_system == UMS_LIMIT)
+    measurement_system = UMS_SI;
 
-  // Getting the number formatting based on the locale and writing to
-  // dictionary.
-  settings->SetString(kNumberFormat, base::FormatDouble(123456.78, 2));
-  settings->SetInteger(kMeasurementSystem, system);
-}
+  // Getting the number formatting based on the locale.
+  StringValue number_format(base::FormatDouble(123456.78, 2));
+  base::FundamentalValue system(measurement_system);
 
-void PrintPreviewHandler::GetLastUsedMarginSettings(
-    base::DictionaryValue* custom_margins) {
-  custom_margins->SetInteger(printing::kSettingMarginsType,
-                             PrintPreviewHandler::last_used_margins_type_);
-  if (last_used_page_size_margins_) {
-    custom_margins->SetDouble(printing::kSettingMarginTop,
-                              last_used_page_size_margins_->margin_top);
-    custom_margins->SetDouble(printing::kSettingMarginBottom,
-                              last_used_page_size_margins_->margin_bottom);
-    custom_margins->SetDouble(printing::kSettingMarginLeft,
-                              last_used_page_size_margins_->margin_left);
-    custom_margins->SetDouble(printing::kSettingMarginRight,
-                              last_used_page_size_margins_->margin_right);
-  }
-}
-
-void PrintPreviewHandler::HandleGetInitialSettings(const ListValue* /*args*/) {
-  scoped_refptr<PrintSystemTaskProxy> task =
-      new PrintSystemTaskProxy(AsWeakPtr(),
-                               print_backend_.get(),
-                               has_logged_printers_count_);
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&PrintSystemTaskProxy::GetDefaultPrinter, task.get()));
-}
-
-void PrintPreviewHandler::SendInitialSettings(
-    const std::string& default_printer,
-    const std::string& cloud_print_data) {
-  PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(web_ui_);
-
-  base::DictionaryValue initial_settings;
-  initial_settings.SetString(kInitiatorTabTitle,
-                             print_preview_ui->initiator_tab_title());
-  initial_settings.SetBoolean(printing::kSettingPreviewModifiable,
-                              print_preview_ui->source_is_modifiable());
-  initial_settings.SetString(printing::kSettingPrinterName,
-                             default_printer);
-  initial_settings.SetString(kCloudPrintData, cloud_print_data);
-
-  if (print_preview_ui->source_is_modifiable()) {
-    GetLastUsedMarginSettings(&initial_settings);
-    GetNumberFormatAndMeasurementSystem(&initial_settings);
-  }
-  web_ui_->CallJavascriptFunction("setInitialSettings", initial_settings);
+  web_ui_->CallJavascriptFunction(
+      "print_preview.setNumberFormatAndMeasurementSystem",
+      number_format,
+      system);
 }
 
 void PrintPreviewHandler::ActivateInitiatorTabAndClosePreviewTab() {
   TabContentsWrapper* initiator_tab = GetInitiatorTab();
   if (initiator_tab) {
     static_cast<RenderViewHostDelegate*>(
         initiator_tab->tab_contents())->Activate();
   }
   ClosePrintPreviewTab();
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
     const DictionaryValue& settings_info) {
   VLOG(1) << "Get printer capabilities finished";
   web_ui_->CallJavascriptFunction("updateWithPrinterCapabilities",
                                   settings_info);
 }
 
+void PrintPreviewHandler::SendDefaultPrinter(
+    const StringValue& default_printer,
+    const StringValue& cloud_print_data) {
+  base::FundamentalValue margins_type(
+      PrintPreviewHandler::last_used_margins_type_);
+  web_ui_->CallJavascriptFunction("setDefaultPrinter",
+                                  default_printer,
+                                  cloud_print_data,
+                                  margins_type);
+}
+
 void PrintPreviewHandler::SetupPrinterList(const ListValue& printers) {
   SendCloudPrintEnabled();
   web_ui_->CallJavascriptFunction("setPrinters", printers);
 }
 
 void PrintPreviewHandler::SendCloudPrintEnabled() {
   Profile* profile = BrowserList::GetLastActive()->profile();
   PrefService* prefs = profile->GetPrefs();
   if (prefs->GetBoolean(prefs::kCloudPrintSubmitEnabled)) {
     GURL gcp_url(CloudPrintURL(profile).GetCloudPrintServiceURL());
@@ skipping 187 matching lines @@
     return;
 
   // We no longer require the initiator tab details. Remove those details
   // associated with the preview tab to allow the initiator tab to create
   // another preview tab.
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
   if (tab_controller)
     tab_controller->EraseInitiatorTabInfo(preview_tab_wrapper());
 }