src/chrome/browser/ui/webui/print_preview/print_preview_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/print_preview/print_preview_handler.h"
   6
   7 #include <ctype.h>
   8
   9 #include <map>
  10 #include <string>
  11
  12 #include "base/base64.h"
  13 #include "base/bind.h"
  14 #include "base/bind_helpers.h"
  15 #include "base/command_line.h"
  16 #include "base/i18n/file_util_icu.h"
  17 #include "base/i18n/number_formatting.h"
  18 #include "base/json/json_reader.h"
  19 #include "base/lazy_instance.h"
  20 #include "base/memory/linked_ptr.h"
  21 #include "base/memory/ref_counted_memory.h"
  22 #include "base/metrics/histogram.h"
  23 #include "base/path_service.h"
  24 #include "base/prefs/pref_service.h"
  25 #include "base/strings/string_number_conversions.h"
  26 #include "base/strings/utf_string_conversions.h"
  27 #include "base/threading/thread.h"
  28 #include "base/threading/thread_restrictions.h"
  29 #include "base/values.h"
  30 #include "chrome/browser/app_mode/app_mode_utils.h"
  31 #include "chrome/browser/browser_process.h"
  32 #include "chrome/browser/platform_util.h"
  33 #include "chrome/browser/printing/print_dialog_cloud.h"
  34 #include "chrome/browser/printing/print_error_dialog.h"
  35 #include "chrome/browser/printing/print_job_manager.h"
  36 #include "chrome/browser/printing/print_preview_dialog_controller.h"
  37 #include "chrome/browser/printing/print_view_manager.h"
  38 #include "chrome/browser/printing/printer_manager_dialog.h"
  39 #include "chrome/browser/profiles/profile.h"
  40 #include "chrome/browser/signin/account_reconcilor_factory.h"
  41 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
  42 #include "chrome/browser/signin/signin_manager_factory.h"
  43 #include "chrome/browser/ui/browser_finder.h"
  44 #include "chrome/browser/ui/browser_tabstrip.h"
  45 #include "chrome/browser/ui/chrome_select_file_policy.h"
  46 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
  47 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
  48 #include "chrome/browser/ui/webui/print_preview/sticky_settings.h"
  49 #include "chrome/common/chrome_paths.h"
  50 #include "chrome/common/chrome_switches.h"
  51 #include "chrome/common/cloud_print/cloud_print_cdd_conversion.h"
  52 #include "chrome/common/cloud_print/cloud_print_constants.h"
  53 #include "chrome/common/crash_keys.h"
  54 #include "chrome/common/pref_names.h"
  55 #include "chrome/common/print_messages.h"
  56 #include "components/cloud_devices/common/cloud_device_description.h"
  57 #include "components/cloud_devices/common/cloud_devices_urls.h"
  58 #include "components/cloud_devices/common/printer_description.h"
  59 #include "components/signin/core/browser/account_reconcilor.h"
  60 #include "components/signin/core/browser/profile_oauth2_token_service.h"
  61 #include "components/signin/core/browser/signin_manager.h"
  62 #include "components/signin/core/common/profile_management_switches.h"
  63 #include "content/public/browser/browser_context.h"
  64 #include "content/public/browser/browser_thread.h"
  65 #include "content/public/browser/navigation_controller.h"
  66 #include "content/public/browser/navigation_entry.h"
  67 #include "content/public/browser/render_process_host.h"
  68 #include "content/public/browser/render_view_host.h"
  69 #include "content/public/browser/web_contents.h"
  70 #include "content/public/browser/web_ui.h"
  71 #include "google_apis/gaia/oauth2_token_service.h"
  72 #include "printing/backend/print_backend.h"
  73 #include "printing/backend/print_backend_consts.h"
  74 #include "printing/metafile.h"
  75 #include "printing/pdf_metafile_skia.h"
  76 #include "printing/pdf_render_settings.h"
  77 #include "printing/print_settings.h"
  78 #include "printing/printing_context.h"
  79 #include "printing/units.h"
  80 #include "third_party/icu/source/i18n/unicode/ulocdata.h"
  81
  82 #if defined(OS_CHROMEOS)
  83 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
  84 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
  85 #endif
  86
  87 #if defined(ENABLE_SERVICE_DISCOVERY)
  88 #include "chrome/browser/local_discovery/privet_constants.h"
  89 #endif
  90
  91 using content::BrowserThread;
  92 using content::RenderViewHost;
  93 using content::WebContents;
  94
  95 namespace {
  96
  97 enum UserActionBuckets {
  98   PRINT_TO_PRINTER,
  99   PRINT_TO_PDF,
 100   CANCEL,
 101   FALLBACK_TO_ADVANCED_SETTINGS_DIALOG,
 102   PREVIEW_FAILED,
 103   PREVIEW_STARTED,
 104   INITIATOR_CRASHED,  // UNUSED
 105   INITIATOR_CLOSED,
 106   PRINT_WITH_CLOUD_PRINT,
 107   PRINT_WITH_PRIVET,
 108   USERACTION_BUCKET_BOUNDARY
 109 };
 110
 111 enum PrintSettingsBuckets {
 112   LANDSCAPE = 0,
 113   PORTRAIT,
 114   COLOR,
 115   BLACK_AND_WHITE,
 116   COLLATE,
 117   SIMPLEX,
 118   DUPLEX,
 119   TOTAL,
 120   HEADERS_AND_FOOTERS,
 121   CSS_BACKGROUND,
 122   SELECTION_ONLY,
 123   EXTERNAL_PDF_PREVIEW,
 124   PAGE_RANGE,
 125   DEFAULT_MEDIA,
 126   NON_DEFAULT_MEDIA,
 127   COPIES,
 128   NON_DEFAULT_MARGINS,
 129   PRINT_SETTINGS_BUCKET_BOUNDARY
 130 };
 131
 132 void ReportUserActionHistogram(enum UserActionBuckets event) {
 133   UMA_HISTOGRAM_ENUMERATION("PrintPreview.UserAction", event,
 134                             USERACTION_BUCKET_BOUNDARY);
 135 }
 136
 137 void ReportPrintSettingHistogram(enum PrintSettingsBuckets setting) {
 138   UMA_HISTOGRAM_ENUMERATION("PrintPreview.PrintSettings", setting,
 139                             PRINT_SETTINGS_BUCKET_BOUNDARY);
 140 }
 141
 142 // Name of a dictionary field holding cloud print related data;
 143 const char kAppState[] = "appState";
 144 // Name of a dictionary field holding the initiator title.
 145 const char kInitiatorTitle[] = "initiatorTitle";
 146 // Name of a dictionary field holding the measurement system according to the
 147 // locale.
 148 const char kMeasurementSystem[] = "measurementSystem";
 149 // Name of a dictionary field holding the number format according to the locale.
 150 const char kNumberFormat[] = "numberFormat";
 151 // Name of a dictionary field specifying whether to print automatically in
 152 // kiosk mode. See http://crbug.com/31395.
 153 const char kPrintAutomaticallyInKioskMode[] = "printAutomaticallyInKioskMode";
 154 // Dictionary field to indicate whether Chrome is running in forced app (app
 155 // kiosk) mode. It's not the same as desktop Chrome kiosk (the one above).
 156 const char kAppKioskMode[] = "appKioskMode";
 157 // Dictionary field to store Cloud Print base URL.
 158 const char kCloudPrintUrl[] = "cloudPrintUrl";
 159 #if defined(OS_WIN)
 160 const char kHidePrintWithSystemDialogLink[] = "hidePrintWithSystemDialogLink";
 161 #endif
 162 // Name of a dictionary field holding the state of selection for document.
 163 const char kDocumentHasSelection[] = "documentHasSelection";
 164
 165 // Id of the predefined PDF printer.
 166 const char kLocalPdfPrinterId[] = "Save as PDF";
 167
 168 // Additional printer capability setting keys.
 169 const char kPrinterId[] = "printerId";
 170 const char kPrinterCapabilities[] = "capabilities";
 171
 172 // Get the print job settings dictionary from |args|. The caller takes
 173 // ownership of the returned DictionaryValue. Returns NULL on failure.
 174 base::DictionaryValue* GetSettingsDictionary(const base::ListValue* args) {
 175   std::string json_str;
 176   if (!args->GetString(0, &json_str)) {
 177     NOTREACHED() << "Could not read JSON argument";
 178     return NULL;
 179   }
 180   if (json_str.empty()) {
 181     NOTREACHED() << "Empty print job settings";
 182     return NULL;
 183   }
 184   scoped_ptr<base::DictionaryValue> settings(
 185       static_cast<base::DictionaryValue*>(
 186           base::JSONReader::Read(json_str)));
 187   if (!settings.get() || !settings->IsType(base::Value::TYPE_DICTIONARY)) {
 188     NOTREACHED() << "Print job settings must be a dictionary.";
 189     return NULL;
 190   }
 191
 192   if (settings->empty()) {
 193     NOTREACHED() << "Print job settings dictionary is empty";
 194     return NULL;
 195   }
 196
 197   return settings.release();
 198 }
 199
 200 // Track the popularity of print settings and report the stats.
 201 void ReportPrintSettingsStats(const base::DictionaryValue& settings) {
 202   ReportPrintSettingHistogram(TOTAL);
 203
 204   const base::ListValue* page_range_array = NULL;
 205   if (settings.GetList(printing::kSettingPageRange, &page_range_array) &&
 206       !page_range_array->empty()) {
 207     ReportPrintSettingHistogram(PAGE_RANGE);
 208   }
 209
 210   const base::DictionaryValue* media_size_value = NULL;
 211   if (settings.GetDictionary(printing::kSettingMediaSize, &media_size_value) &&
 212       !media_size_value->empty()) {
 213     bool is_default = false;
 214     if (media_size_value->GetBoolean(printing::kSettingMediaSizeIsDefault,
 215                                      &is_default) &&
 216         is_default) {
 217       ReportPrintSettingHistogram(DEFAULT_MEDIA);
 218     } else {
 219       ReportPrintSettingHistogram(NON_DEFAULT_MEDIA);
 220     }
 221   }
 222
 223   bool landscape = false;
 224   if (settings.GetBoolean(printing::kSettingLandscape, &landscape))
 225     ReportPrintSettingHistogram(landscape ? LANDSCAPE : PORTRAIT);
 226
 227   int copies = 1;
 228   if (settings.GetInteger(printing::kSettingCopies, &copies) && copies > 1)
 229     ReportPrintSettingHistogram(COPIES);
 230
 231   bool collate = false;
 232   if (settings.GetBoolean(printing::kSettingCollate, &collate) && collate)
 233     ReportPrintSettingHistogram(COLLATE);
 234
 235   int duplex_mode = 0;
 236   if (settings.GetInteger(printing::kSettingDuplexMode, &duplex_mode))
 237     ReportPrintSettingHistogram(duplex_mode ? DUPLEX : SIMPLEX);
 238
 239   int color_mode = 0;
 240   if (settings.GetInteger(printing::kSettingColor, &color_mode)) {
 241     ReportPrintSettingHistogram(
 242         printing::IsColorModelSelected(color_mode) ? COLOR : BLACK_AND_WHITE);
 243   }
 244
 245   int margins_type = 0;
 246   if (settings.GetInteger(printing::kSettingMarginsType, &margins_type) &&
 247       margins_type != 0) {
 248     ReportPrintSettingHistogram(NON_DEFAULT_MARGINS);
 249   }
 250
 251   bool headers = false;
 252   if (settings.GetBoolean(printing::kSettingHeaderFooterEnabled, &headers) &&
 253       headers) {
 254     ReportPrintSettingHistogram(HEADERS_AND_FOOTERS);
 255   }
 256
 257   bool css_background = false;
 258   if (settings.GetBoolean(printing::kSettingShouldPrintBackgrounds,
 259                           &css_background) && css_background) {
 260     ReportPrintSettingHistogram(CSS_BACKGROUND);
 261   }
 262
 263   bool selection_only = false;
 264   if (settings.GetBoolean(printing::kSettingShouldPrintSelectionOnly,
 265                           &selection_only) && selection_only) {
 266     ReportPrintSettingHistogram(SELECTION_ONLY);
 267   }
 268
 269   bool external_preview = false;
 270   if (settings.GetBoolean(printing::kSettingOpenPDFInPreview,
 271                           &external_preview) && external_preview) {
 272     ReportPrintSettingHistogram(EXTERNAL_PDF_PREVIEW);
 273   }
 274 }
 275
 276 // Callback that stores a PDF file on disk.
 277 void PrintToPdfCallback(const scoped_refptr<base::RefCountedBytes>& data,
 278                         const base::FilePath& path,
 279                         const base::Closure& pdf_file_saved_closure) {
 280   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 281   printing::PdfMetafileSkia metafile;
 282   metafile.InitFromData(static_cast<const void*>(data->front()), data->size());
 283   base::File file(path,
 284                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
 285   metafile.SaveTo(&file);
 286   if (!pdf_file_saved_closure.is_null())
 287     pdf_file_saved_closure.Run();
 288 }
 289
 290 std::string GetDefaultPrinterOnFileThread() {
 291   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 292
 293   scoped_refptr<printing::PrintBackend> print_backend(
 294       printing::PrintBackend::CreateInstance(NULL));
 295
 296   std::string default_printer = print_backend->GetDefaultPrinterName();
 297   VLOG(1) << "Default Printer: " << default_printer;
 298   return default_printer;
 299 }
 300
 301 class PrintingContextDelegate : public printing::PrintingContext::Delegate {
 302  public:
 303   // PrintingContext::Delegate methods.
 304   virtual gfx::NativeView GetParentView() OVERRIDE { return NULL; }
 305   virtual std::string GetAppLocale() OVERRIDE {
 306     return g_browser_process->GetApplicationLocale();
 307   }
 308 };
 309
 310 gfx::Size GetDefaultPdfMediaSizeMicrons() {
 311   PrintingContextDelegate delegate;
 312   scoped_ptr<printing::PrintingContext> printing_context(
 313       printing::PrintingContext::Create(&delegate));
 314   if (printing::PrintingContext::OK != printing_context->UsePdfSettings() ||
 315       printing_context->settings().device_units_per_inch() <= 0) {
 316     return gfx::Size();
 317   }
 318   gfx::Size pdf_media_size = printing_context->GetPdfPaperSizeDeviceUnits();
 319   float deviceMicronsPerDeviceUnit =
 320       (printing::kHundrethsMMPerInch * 10.0f) /
 321       printing_context->settings().device_units_per_inch();
 322   return gfx::Size(pdf_media_size.width() * deviceMicronsPerDeviceUnit,
 323                    pdf_media_size.height() * deviceMicronsPerDeviceUnit);
 324 }
 325
 326 typedef base::Callback<void(const base::DictionaryValue*)>
 327     GetPdfCapabilitiesCallback;
 328
 329 scoped_ptr<base::DictionaryValue> GetPdfCapabilitiesOnFileThread(
 330     const std::string& locale) {
 331   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 332
 333   cloud_devices::CloudDeviceDescription description;
 334   using namespace cloud_devices::printer;
 335
 336   OrientationCapability orientation;
 337   orientation.AddOption(cloud_devices::printer::PORTRAIT);
 338   orientation.AddOption(cloud_devices::printer::LANDSCAPE);
 339   orientation.AddDefaultOption(AUTO_ORIENTATION, true);
 340   orientation.SaveTo(&description);
 341
 342   ColorCapability color;
 343   {
 344     Color standard_color(STANDARD_COLOR);
 345     standard_color.vendor_id = base::IntToString(printing::COLOR);
 346     color.AddDefaultOption(standard_color, true);
 347   }
 348   color.SaveTo(&description);
 349
 350   static const cloud_devices::printer::MediaType kPdfMedia[] = {
 351     ISO_A4,
 352     ISO_A3,
 353     NA_LETTER,
 354     NA_LEGAL,
 355     NA_LEDGER
 356   };
 357   const gfx::Size default_media_size = GetDefaultPdfMediaSizeMicrons();
 358   Media default_media(
 359       "", "", default_media_size.width(), default_media_size.height());
 360   if (!default_media.MatchBySize() ||
 361       std::find(kPdfMedia,
 362                 kPdfMedia + arraysize(kPdfMedia),
 363                 default_media.type) == kPdfMedia + arraysize(kPdfMedia)) {
 364     default_media = Media(locale == "en-US" ? NA_LETTER : ISO_A4);
 365   }
 366   MediaCapability media;
 367   for (size_t i = 0; i < arraysize(kPdfMedia); ++i) {
 368     Media media_option(kPdfMedia[i]);
 369     media.AddDefaultOption(media_option,
 370                            default_media.type == media_option.type);
 371   }
 372   media.SaveTo(&description);
 373
 374   return scoped_ptr<base::DictionaryValue>(description.root().DeepCopy());
 375 }
 376
 377 scoped_ptr<base::DictionaryValue> GetLocalPrinterCapabilitiesOnFileThread(
 378     const std::string& printer_name) {
 379   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 380
 381   scoped_refptr<printing::PrintBackend> print_backend(
 382       printing::PrintBackend::CreateInstance(NULL));
 383
 384   VLOG(1) << "Get printer capabilities start for " << printer_name;
 385   crash_keys::ScopedPrinterInfo crash_key(
 386       print_backend->GetPrinterDriverInfo(printer_name));
 387
 388   if (!print_backend->IsValidPrinter(printer_name)) {
 389     LOG(WARNING) << "Invalid printer " << printer_name;
 390     return scoped_ptr<base::DictionaryValue>();
 391   }
 392
 393   printing::PrinterSemanticCapsAndDefaults info;
 394   if (!print_backend->GetPrinterSemanticCapsAndDefaults(printer_name, &info)) {
 395     LOG(WARNING) << "Failed to get capabilities for " << printer_name;
 396     return scoped_ptr<base::DictionaryValue>();
 397   }
 398
 399   scoped_ptr<base::DictionaryValue> description(
 400       cloud_print::PrinterSemanticCapsAndDefaultsToCdd(info));
 401   if (!description) {
 402     LOG(WARNING) << "Failed to convert capabilities for " << printer_name;
 403     return scoped_ptr<base::DictionaryValue>();
 404   }
 405
 406   return description.Pass();
 407 }
 408
 409 void EnumeratePrintersOnFileThread(base::ListValue* printers) {
 410   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 411
 412   scoped_refptr<printing::PrintBackend> print_backend(
 413       printing::PrintBackend::CreateInstance(NULL));
 414
 415   VLOG(1) << "Enumerate printers start";
 416   printing::PrinterList printer_list;
 417   print_backend->EnumeratePrinters(&printer_list);
 418
 419   for (printing::PrinterList::iterator it = printer_list.begin();
 420        it != printer_list.end(); ++it) {
 421     base::DictionaryValue* printer_info = new base::DictionaryValue;
 422     printers->Append(printer_info);
 423     std::string printer_name;
 424     std::string printer_description;
 425 #if defined(OS_MACOSX)
 426     // On Mac, |it->printer_description| specifies the printer name and
 427     // |it->printer_name| specifies the device name / printer queue name.
 428     printer_name = it->printer_description;
 429     if (!it->options[kDriverNameTagName].empty())
 430       printer_description = it->options[kDriverNameTagName];
 431 #else
 432     printer_name = it->printer_name;
 433     printer_description = it->printer_description;
 434 #endif
 435     printer_info->SetString(printing::kSettingDeviceName, it->printer_name);
 436     printer_info->SetString(printing::kSettingPrinterDescription,
 437                             printer_description);
 438     printer_info->SetString(printing::kSettingPrinterName, printer_name);
 439     VLOG(1) << "Found printer " << printer_name
 440             << " with device name " << it->printer_name;
 441
 442     base::DictionaryValue* options = new base::DictionaryValue;
 443     printer_info->Set(printing::kSettingPrinterOptions, options);
 444     for (std::map<std::string, std::string>::iterator opt = it->options.begin();
 445          opt != it->options.end();
 446          ++opt) {
 447       options->SetString(opt->first, opt->second);
 448     }
 449
 450     VLOG(1) << "Found printer " << printer_name << " with device name "
 451             << it->printer_name;
 452   }
 453   VLOG(1) << "Enumerate printers finished, found " << printers->GetSize()
 454           << " printers";
 455 }
 456
 457 typedef base::Callback<void(const base::DictionaryValue*)>
 458     GetPrinterCapabilitiesSuccessCallback;
 459 typedef base::Callback<void(const std::string&)>
 460     GetPrinterCapabilitiesFailureCallback;
 461
 462 void GetPrinterCapabilitiesOnFileThread(
 463     const std::string& printer_name,
 464     const std::string& locale,
 465     const GetPrinterCapabilitiesSuccessCallback& success_cb,
 466     const GetPrinterCapabilitiesFailureCallback& failure_cb) {
 467   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 468   DCHECK(!printer_name.empty());
 469
 470   scoped_ptr<base::DictionaryValue> printer_capabilities(
 471       printer_name == kLocalPdfPrinterId ?
 472       GetPdfCapabilitiesOnFileThread(locale) :
 473       GetLocalPrinterCapabilitiesOnFileThread(printer_name));
 474   if (!printer_capabilities) {
 475     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 476                             base::Bind(failure_cb, printer_name));
 477     return;
 478   }
 479
 480   scoped_ptr<base::DictionaryValue> printer_info(new base::DictionaryValue);
 481   printer_info->SetString(kPrinterId, printer_name);
 482   printer_info->Set(kPrinterCapabilities, printer_capabilities.release());
 483
 484   BrowserThread::PostTask(
 485       BrowserThread::UI, FROM_HERE,
 486       base::Bind(success_cb, base::Owned(printer_info.release())));
 487 }
 488
 489 base::LazyInstance<printing::StickySettings> g_sticky_settings =
 490     LAZY_INSTANCE_INITIALIZER;
 491
 492 printing::StickySettings* GetStickySettings() {
 493   return g_sticky_settings.Pointer();
 494 }
 495
 496 }  // namespace
 497
 498 class PrintPreviewHandler::AccessTokenService
 499     : public OAuth2TokenService::Consumer {
 500  public:
 501   explicit AccessTokenService(PrintPreviewHandler* handler)
 502       : OAuth2TokenService::Consumer("print_preview"),
 503         handler_(handler) {
 504   }
 505
 506   void RequestToken(const std::string& type) {
 507     if (requests_.find(type) != requests_.end())
 508       return;  // Already in progress.
 509
 510     OAuth2TokenService* service = NULL;
 511     std::string account_id;
 512     if (type == "profile") {
 513       Profile* profile = Profile::FromWebUI(handler_->web_ui());
 514       if (profile) {
 515         ProfileOAuth2TokenService* token_service =
 516             ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
 517         SigninManagerBase* signin_manager =
 518             SigninManagerFactory::GetInstance()->GetForProfile(profile);
 519         account_id = signin_manager->GetAuthenticatedAccountId();
 520         service = token_service;
 521       }
 522     } else if (type == "device") {
 523 #if defined(OS_CHROMEOS)
 524       chromeos::DeviceOAuth2TokenService* token_service =
 525           chromeos::DeviceOAuth2TokenServiceFactory::Get();
 526       account_id = token_service->GetRobotAccountId();
 527       service = token_service;
 528 #endif
 529     }
 530
 531     if (service) {
 532       OAuth2TokenService::ScopeSet oauth_scopes;
 533       oauth_scopes.insert(cloud_devices::kCloudPrintAuthScope);
 534       scoped_ptr<OAuth2TokenService::Request> request(
 535           service->StartRequest(account_id, oauth_scopes, this));
 536       requests_[type].reset(request.release());
 537     } else {
 538       handler_->SendAccessToken(type, std::string());  // Unknown type.
 539     }
 540   }
 541
 542   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
 543                                  const std::string& access_token,
 544                                  const base::Time& expiration_time) OVERRIDE {
 545     OnServiceResponce(request, access_token);
 546   }
 547
 548   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
 549                                  const GoogleServiceAuthError& error) OVERRIDE {
 550     OnServiceResponce(request, std::string());
 551   }
 552
 553  private:
 554   void OnServiceResponce(const OAuth2TokenService::Request* request,
 555                          const std::string& access_token) {
 556     for (Requests::iterator i = requests_.begin(); i != requests_.end(); ++i) {
 557       if (i->second == request) {
 558         handler_->SendAccessToken(i->first, access_token);
 559         requests_.erase(i);
 560         return;
 561       }
 562     }
 563     NOTREACHED();
 564   }
 565
 566   typedef std::map<std::string,
 567                    linked_ptr<OAuth2TokenService::Request> > Requests;
 568   Requests requests_;
 569   PrintPreviewHandler* handler_;
 570
 571   DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
 572 };
 573
 574 PrintPreviewHandler::PrintPreviewHandler()
 575     : regenerate_preview_request_count_(0),
 576       manage_printers_dialog_request_count_(0),
 577       manage_cloud_printers_dialog_request_count_(0),
 578       reported_failed_preview_(false),
 579       has_logged_printers_count_(false),
 580       reconcilor_(NULL),
 581       weak_factory_(this) {
 582   ReportUserActionHistogram(PREVIEW_STARTED);
 583 }
 584
 585 PrintPreviewHandler::~PrintPreviewHandler() {
 586   if (select_file_dialog_.get())
 587     select_file_dialog_->ListenerDestroyed();
 588
 589   UnregisterForMergeSession();
 590 }
 591
 592 void PrintPreviewHandler::RegisterMessages() {
 593   web_ui()->RegisterMessageCallback("getPrinters",
 594       base::Bind(&PrintPreviewHandler::HandleGetPrinters,
 595                  base::Unretained(this)));
 596   web_ui()->RegisterMessageCallback("getPreview",
 597       base::Bind(&PrintPreviewHandler::HandleGetPreview,
 598                  base::Unretained(this)));
 599   web_ui()->RegisterMessageCallback("print",
 600       base::Bind(&PrintPreviewHandler::HandlePrint,
 601                  base::Unretained(this)));
 602   web_ui()->RegisterMessageCallback("getPrinterCapabilities",
 603       base::Bind(&PrintPreviewHandler::HandleGetPrinterCapabilities,
 604                  base::Unretained(this)));
 605 #if !defined(DISABLE_BASIC_PRINTING)
 606   web_ui()->RegisterMessageCallback("showSystemDialog",
 607       base::Bind(&PrintPreviewHandler::HandleShowSystemDialog,
 608                  base::Unretained(this)));
 609 #endif  // !DISABLE_BASIC_PRINTING
 610   web_ui()->RegisterMessageCallback("signIn",
 611       base::Bind(&PrintPreviewHandler::HandleSignin,
 612                  base::Unretained(this)));
 613   web_ui()->RegisterMessageCallback("getAccessToken",
 614       base::Bind(&PrintPreviewHandler::HandleGetAccessToken,
 615                  base::Unretained(this)));
 616   web_ui()->RegisterMessageCallback("manageCloudPrinters",
 617       base::Bind(&PrintPreviewHandler::HandleManageCloudPrint,
 618                  base::Unretained(this)));
 619   web_ui()->RegisterMessageCallback("manageLocalPrinters",
 620       base::Bind(&PrintPreviewHandler::HandleManagePrinters,
 621                  base::Unretained(this)));
 622   web_ui()->RegisterMessageCallback("closePrintPreviewDialog",
 623       base::Bind(&PrintPreviewHandler::HandleClosePreviewDialog,
 624                  base::Unretained(this)));
 625   web_ui()->RegisterMessageCallback("hidePreview",
 626       base::Bind(&PrintPreviewHandler::HandleHidePreview,
 627                  base::Unretained(this)));
 628   web_ui()->RegisterMessageCallback("cancelPendingPrintRequest",
 629       base::Bind(&PrintPreviewHandler::HandleCancelPendingPrintRequest,
 630                  base::Unretained(this)));
 631   web_ui()->RegisterMessageCallback("saveAppState",
 632       base::Bind(&PrintPreviewHandler::HandleSaveAppState,
 633                  base::Unretained(this)));
 634   web_ui()->RegisterMessageCallback("getInitialSettings",
 635       base::Bind(&PrintPreviewHandler::HandleGetInitialSettings,
 636                  base::Unretained(this)));
 637   web_ui()->RegisterMessageCallback("printWithCloudPrintDialog",
 638       base::Bind(&PrintPreviewHandler::HandlePrintWithCloudPrintDialog,
 639                  base::Unretained(this)));
 640   web_ui()->RegisterMessageCallback("forceOpenNewTab",
 641       base::Bind(&PrintPreviewHandler::HandleForceOpenNewTab,
 642                  base::Unretained(this)));
 643   web_ui()->RegisterMessageCallback("getPrivetPrinters",
 644       base::Bind(&PrintPreviewHandler::HandleGetPrivetPrinters,
 645                  base::Unretained(this)));
 646   web_ui()->RegisterMessageCallback("stopGetPrivetPrinters",
 647       base::Bind(&PrintPreviewHandler::HandleStopGetPrivetPrinters,
 648                  base::Unretained(this)));
 649   web_ui()->RegisterMessageCallback("getPrivetPrinterCapabilities",
 650       base::Bind(&PrintPreviewHandler::HandleGetPrivetPrinterCapabilities,
 651                  base::Unretained(this)));
 652   RegisterForMergeSession();
 653 }
 654
 655 bool PrintPreviewHandler::PrivetPrintingEnabled() {
 656 #if defined(ENABLE_SERVICE_DISCOVERY)
 657   return true;
 658 #else
 659   return false;
 660 #endif
 661 }
 662
 663 WebContents* PrintPreviewHandler::preview_web_contents() const {
 664   return web_ui()->GetWebContents();
 665 }
 666
 667 void PrintPreviewHandler::HandleGetPrinters(const base::ListValue* /*args*/) {
 668   base::ListValue* results = new base::ListValue;
 669   BrowserThread::PostTaskAndReply(
 670       BrowserThread::FILE, FROM_HERE,
 671       base::Bind(&EnumeratePrintersOnFileThread,
 672                  base::Unretained(results)),
 673       base::Bind(&PrintPreviewHandler::SetupPrinterList,
 674                  weak_factory_.GetWeakPtr(),
 675                  base::Owned(results)));
 676 }
 677
 678 void PrintPreviewHandler::HandleGetPrivetPrinters(const base::ListValue* args) {
 679   if (!PrivetPrintingEnabled())
 680     return web_ui()->CallJavascriptFunction("onPrivetPrinterSearchDone");
 681 #if defined(ENABLE_SERVICE_DISCOVERY)
 682   local_discovery::ServiceDiscoverySharedClient::GetInstanceWithoutAlert(
 683       base::Bind(&PrintPreviewHandler::StartPrivetLister,
 684                  weak_factory_.GetWeakPtr()));
 685 #endif  // ENABLE_SERVICE_DISCOVERY
 686 }
 687
 688 void PrintPreviewHandler::HandleStopGetPrivetPrinters(
 689     const base::ListValue* args) {
 690 #if defined(ENABLE_SERVICE_DISCOVERY)
 691   if (PrivetPrintingEnabled() && printer_lister_) {
 692     printer_lister_->Stop();
 693   }
 694 #endif
 695 }
 696
 697 void PrintPreviewHandler::HandleGetPrivetPrinterCapabilities(
 698     const base::ListValue* args) {
 699 #if defined(ENABLE_SERVICE_DISCOVERY)
 700   std::string name;
 701   bool success = args->GetString(0, &name);
 702   DCHECK(success);
 703
 704   CreatePrivetHTTP(
 705       name,
 706       base::Bind(&PrintPreviewHandler::PrivetCapabilitiesUpdateClient,
 707                  base::Unretained(this)));
 708 #endif
 709 }
 710
 711 void PrintPreviewHandler::HandleGetPreview(const base::ListValue* args) {
 712   DCHECK_EQ(3U, args->GetSize());
 713   scoped_ptr<base::DictionaryValue> settings(GetSettingsDictionary(args));
 714   if (!settings.get())
 715     return;
 716   int request_id = -1;
 717   if (!settings->GetInteger(printing::kPreviewRequestID, &request_id))
 718     return;
 719
 720   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
 721       web_ui()->GetController());
 722   print_preview_ui->OnPrintPreviewRequest(request_id);
 723   // Add an additional key in order to identify |print_preview_ui| later on
 724   // when calling PrintPreviewUI::GetCurrentPrintPreviewStatus() on the IO
 725   // thread.
 726   settings->SetInteger(printing::kPreviewUIID,
 727                        print_preview_ui->GetIDForPrintPreviewUI());
 728
 729   // Increment request count.
 730   ++regenerate_preview_request_count_;
 731
 732   WebContents* initiator = GetInitiator();
 733   if (!initiator) {
 734     ReportUserActionHistogram(INITIATOR_CLOSED);
 735     print_preview_ui->OnClosePrintPreviewDialog();
 736     return;
 737   }
 738
 739   // Retrieve the page title and url and send it to the renderer process if
 740   // headers and footers are to be displayed.
 741   bool display_header_footer = false;
 742   if (!settings->GetBoolean(printing::kSettingHeaderFooterEnabled,
 743                             &display_header_footer)) {
 744     NOTREACHED();
 745   }
 746   if (display_header_footer) {
 747     settings->SetString(printing::kSettingHeaderFooterTitle,
 748                         initiator->GetTitle());
 749     std::string url;
 750     content::NavigationEntry* entry =
 751         initiator->GetController().GetLastCommittedEntry();
 752     if (entry)
 753       url = entry->GetVirtualURL().spec();
 754     settings->SetString(printing::kSettingHeaderFooterURL, url);
 755   }
 756
 757   bool generate_draft_data = false;
 758   bool success = settings->GetBoolean(printing::kSettingGenerateDraftData,
 759                                       &generate_draft_data);
 760   DCHECK(success);
 761
 762   if (!generate_draft_data) {
 763     double draft_page_count_double = -1;
 764     success = args->GetDouble(1, &draft_page_count_double);
 765     DCHECK(success);
 766     int draft_page_count = static_cast<int>(draft_page_count_double);
 767
 768     bool preview_modifiable = false;
 769     success = args->GetBoolean(2, &preview_modifiable);
 770     DCHECK(success);
 771
 772     if (draft_page_count != -1 && preview_modifiable &&
 773         print_preview_ui->GetAvailableDraftPageCount() != draft_page_count) {
 774       settings->SetBoolean(printing::kSettingGenerateDraftData, true);
 775     }
 776   }
 777
 778   VLOG(1) << "Print preview request start";
 779   RenderViewHost* rvh = initiator->GetRenderViewHost();
 780   rvh->Send(new PrintMsg_PrintPreview(rvh->GetRoutingID(), *settings));
 781 }
 782
 783 void PrintPreviewHandler::HandlePrint(const base::ListValue* args) {
 784   ReportStats();
 785
 786   // Record the number of times the user requests to regenerate preview data
 787   // before printing.
 788   UMA_HISTOGRAM_COUNTS("PrintPreview.RegeneratePreviewRequest.BeforePrint",
 789                        regenerate_preview_request_count_);
 790
 791   scoped_ptr<base::DictionaryValue> settings(GetSettingsDictionary(args));
 792   if (!settings.get())
 793     return;
 794
 795   ReportPrintSettingsStats(*settings);
 796
 797   // Never try to add headers/footers here. It's already in the generated PDF.
 798   settings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
 799
 800   bool print_to_pdf = false;
 801   bool is_cloud_printer = false;
 802   bool print_with_privet = false;
 803
 804   bool open_pdf_in_preview = false;
 805 #if defined(OS_MACOSX)
 806   open_pdf_in_preview = settings->HasKey(printing::kSettingOpenPDFInPreview);
 807 #endif
 808
 809   if (!open_pdf_in_preview) {
 810     settings->GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf);
 811     settings->GetBoolean(printing::kSettingPrintWithPrivet, &print_with_privet);
 812     is_cloud_printer = settings->HasKey(printing::kSettingCloudPrintId);
 813   }
 814
 815   int page_count = 0;
 816   settings->GetInteger(printing::kSettingPreviewPageCount, &page_count);
 817
 818   if (print_to_pdf) {
 819     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToPDF", page_count);
 820     ReportUserActionHistogram(PRINT_TO_PDF);
 821     PrintToPdf();
 822     return;
 823   }
 824
 825 #if defined(ENABLE_SERVICE_DISCOVERY)
 826   if (print_with_privet && PrivetPrintingEnabled()) {
 827     std::string printer_name;
 828     std::string print_ticket;
 829     std::string capabilities;
 830     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintWithPrivet", page_count);
 831     ReportUserActionHistogram(PRINT_WITH_PRIVET);
 832
 833     int width = 0;
 834     int height = 0;
 835     if (!settings->GetString(printing::kSettingDeviceName, &printer_name) ||
 836         !settings->GetString(printing::kSettingTicket, &print_ticket) ||
 837         !settings->GetString(printing::kSettingCapabilities, &capabilities) ||
 838         !settings->GetInteger(printing::kSettingPageWidth, &width) ||
 839         !settings->GetInteger(printing::kSettingPageHeight, &height) ||
 840         width <= 0 || height <= 0) {
 841       NOTREACHED();
 842       base::FundamentalValue http_code_value(-1);
 843       web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
 844       return;
 845     }
 846
 847     PrintToPrivetPrinter(
 848         printer_name, print_ticket, capabilities, gfx::Size(width, height));
 849     return;
 850   }
 851 #endif
 852
 853   scoped_refptr<base::RefCountedBytes> data;
 854   base::string16 title;
 855   if (!GetPreviewDataAndTitle(&data, &title)) {
 856     // Nothing to print, no preview available.
 857     return;
 858   }
 859
 860   if (is_cloud_printer) {
 861     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToCloudPrint",
 862                          page_count);
 863     ReportUserActionHistogram(PRINT_WITH_CLOUD_PRINT);
 864     SendCloudPrintJob(data.get());
 865   } else {
 866     bool system_dialog = false;
 867     settings->GetBoolean(printing::kSettingShowSystemDialog, &system_dialog);
 868     if (system_dialog) {
 869       UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.SystemDialog", page_count);
 870       ReportUserActionHistogram(FALLBACK_TO_ADVANCED_SETTINGS_DIALOG);
 871     } else {
 872       UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToPrinter", page_count);
 873       ReportUserActionHistogram(PRINT_TO_PRINTER);
 874     }
 875
 876     // This tries to activate the initiator as well, so do not clear the
 877     // association with the initiator yet.
 878     PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
 879         web_ui()->GetController());
 880     print_preview_ui->OnHidePreviewDialog();
 881
 882     // Do this so the initiator can open a new print preview dialog, while the
 883     // current print preview dialog is still handling its print job.
 884     WebContents* initiator = GetInitiator();
 885     if (initiator) {
 886       // Save initiator IDs. |PrintingMessageFilter::OnUpdatePrintSettings|
 887       // would be called when initiator info is cleared.
 888       settings->SetInteger(printing::kPreviewInitiatorHostId,
 889                            initiator->GetRenderProcessHost()->GetID());
 890       settings->SetInteger(printing::kPreviewInitiatorRoutingId,
 891                            initiator->GetRoutingID());
 892     }
 893
 894     ClearInitiatorDetails();
 895
 896     // The PDF being printed contains only the pages that the user selected,
 897     // so ignore the page range and print all pages.
 898     settings->Remove(printing::kSettingPageRange, NULL);
 899     // Reset selection only flag for the same reason.
 900     settings->SetBoolean(printing::kSettingShouldPrintSelectionOnly, false);
 901
 902     // Set ID to know whether printing is for preview.
 903     settings->SetInteger(printing::kPreviewUIID,
 904                          print_preview_ui->GetIDForPrintPreviewUI());
 905     RenderViewHost* rvh = preview_web_contents()->GetRenderViewHost();
 906     rvh->Send(new PrintMsg_PrintForPrintPreview(rvh->GetRoutingID(),
 907                                                 *settings));
 908
 909     // For all other cases above, the preview dialog will stay open until the
 910     // printing has finished. Then the dialog closes and PrintPreviewDone() gets
 911     // called. In the case below, since the preview dialog will be hidden and
 912     // not closed, we need to make this call.
 913     if (initiator) {
 914       printing::PrintViewManager* print_view_manager =
 915           printing::PrintViewManager::FromWebContents(initiator);
 916       print_view_manager->PrintPreviewDone();
 917     }
 918   }
 919 }
 920
 921 void PrintPreviewHandler::PrintToPdf() {
 922   if (!print_to_pdf_path_.empty()) {
 923     // User has already selected a path, no need to show the dialog again.
 924     PostPrintToPdfTask();
 925   } else if (!select_file_dialog_.get() ||
 926              !select_file_dialog_->IsRunning(platform_util::GetTopLevel(
 927                  preview_web_contents()->GetNativeView()))) {
 928     PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
 929         web_ui()->GetController());
 930     // Pre-populating select file dialog with print job title.
 931     base::string16 print_job_title_utf16 = print_preview_ui->initiator_title();
 932
 933 #if defined(OS_WIN)
 934     base::FilePath::StringType print_job_title(print_job_title_utf16);
 935 #elif defined(OS_POSIX)
 936     base::FilePath::StringType print_job_title =
 937         base::UTF16ToUTF8(print_job_title_utf16);
 938 #endif
 939
 940     base::i18n::ReplaceIllegalCharactersInPath(&print_job_title, '_');
 941     base::FilePath default_filename(print_job_title);
 942     default_filename =
 943         default_filename.ReplaceExtension(FILE_PATH_LITERAL("pdf"));
 944
 945     SelectFile(default_filename);
 946   }
 947 }
 948
 949 void PrintPreviewHandler::HandleHidePreview(const base::ListValue* /*args*/) {
 950   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
 951       web_ui()->GetController());
 952   print_preview_ui->OnHidePreviewDialog();
 953 }
 954
 955 void PrintPreviewHandler::HandleCancelPendingPrintRequest(
 956     const base::ListValue* /*args*/) {
 957   WebContents* initiator = GetInitiator();
 958   if (initiator)
 959     ClearInitiatorDetails();
 960   chrome::ShowPrintErrorDialog();
 961 }
 962
 963 void PrintPreviewHandler::HandleSaveAppState(const base::ListValue* args) {
 964   std::string data_to_save;
 965   printing::StickySettings* sticky_settings = GetStickySettings();
 966   if (args->GetString(0, &data_to_save) && !data_to_save.empty())
 967     sticky_settings->StoreAppState(data_to_save);
 968   sticky_settings->SaveInPrefs(Profile::FromBrowserContext(
 969       preview_web_contents()->GetBrowserContext())->GetPrefs());
 970 }
 971
 972 void PrintPreviewHandler::HandleGetPrinterCapabilities(
 973     const base::ListValue* args) {
 974   std::string printer_name;
 975   bool ret = args->GetString(0, &printer_name);
 976   if (!ret || printer_name.empty())
 977     return;
 978
 979   GetPrinterCapabilitiesSuccessCallback success_cb =
 980       base::Bind(&PrintPreviewHandler::SendPrinterCapabilities,
 981                  weak_factory_.GetWeakPtr());
 982   GetPrinterCapabilitiesFailureCallback failure_cb =
 983       base::Bind(&PrintPreviewHandler::SendFailedToGetPrinterCapabilities,
 984                  weak_factory_.GetWeakPtr());
 985   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 986                           base::Bind(&GetPrinterCapabilitiesOnFileThread,
 987                                      printer_name,
 988                                      g_browser_process->GetApplicationLocale(),
 989                                      success_cb, failure_cb));
 990 }
 991
 992 void PrintPreviewHandler::OnSigninComplete() {
 993   PrintPreviewUI* print_preview_ui =
 994       static_cast<PrintPreviewUI*>(web_ui()->GetController());
 995   if (print_preview_ui)
 996     print_preview_ui->OnReloadPrintersList();
 997 }
 998
 999 void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
1000   bool add_account = false;
1001   bool success = args->GetBoolean(0, &add_account);
1002   DCHECK(success);
1003
1004   Profile* profile = Profile::FromBrowserContext(
1005       preview_web_contents()->GetBrowserContext());
1006   chrome::ScopedTabbedBrowserDisplayer displayer(
1007       profile, chrome::GetActiveDesktop());
1008   print_dialog_cloud::CreateCloudPrintSigninTab(
1009       displayer.browser(),
1010       add_account,
1011       base::Bind(&PrintPreviewHandler::OnSigninComplete,
1012                  weak_factory_.GetWeakPtr()));
1013 }
1014
1015 void PrintPreviewHandler::HandleGetAccessToken(const base::ListValue* args) {
1016   std::string type;
1017   if (!args->GetString(0, &type))
1018     return;
1019   if (!token_service_)
1020     token_service_.reset(new AccessTokenService(this));
1021   token_service_->RequestToken(type);
1022 }
1023
1024 void PrintPreviewHandler::PrintWithCloudPrintDialog() {
1025   // Record the number of times the user asks to print via cloud print
1026   // instead of the print preview dialog.
1027   ReportStats();
1028
1029   scoped_refptr<base::RefCountedBytes> data;
1030   base::string16 title;
1031   if (!GetPreviewDataAndTitle(&data, &title)) {
1032     // Nothing to print, no preview available.
1033     return;
1034   }
1035
1036   gfx::NativeWindow modal_parent = platform_util::GetTopLevel(
1037       preview_web_contents()->GetNativeView());
1038   print_dialog_cloud::CreatePrintDialogForBytes(
1039       preview_web_contents()->GetBrowserContext(),
1040       modal_parent,
1041       data.get(),
1042       title,
1043       base::string16(),
1044       std::string("application/pdf"));
1045
1046   // Once the cloud print dialog comes up we're no longer in a background
1047   // printing situation.  Close the print preview.
1048   // TODO(abodenha@chromium.org) The flow should be changed as described in
1049   // http://code.google.com/p/chromium/issues/detail?id=44093
1050   ClosePreviewDialog();
1051 }
1052
1053 void PrintPreviewHandler::HandleManageCloudPrint(
1054     const base::ListValue* /*args*/) {
1055   ++manage_cloud_printers_dialog_request_count_;
1056   preview_web_contents()->OpenURL(content::OpenURLParams(
1057       cloud_devices::GetCloudPrintRelativeURL("manage.html"),
1058       content::Referrer(),
1059       NEW_FOREGROUND_TAB,
1060       ui::PAGE_TRANSITION_LINK,
1061       false));
1062 }
1063
1064 #if !defined(DISABLE_BASIC_PRINTING)
1065 void PrintPreviewHandler::HandleShowSystemDialog(
1066     const base::ListValue* /*args*/) {
1067   ReportStats();
1068   ReportUserActionHistogram(FALLBACK_TO_ADVANCED_SETTINGS_DIALOG);
1069
1070   WebContents* initiator = GetInitiator();
1071   if (!initiator)
1072     return;
1073
1074   printing::PrintViewManager* print_view_manager =
1075       printing::PrintViewManager::FromWebContents(initiator);
1076   print_view_manager->set_observer(this);
1077   print_view_manager->PrintForSystemDialogNow();
1078
1079   // Cancel the pending preview request if exists.
1080   PrintPreviewUI* print_preview_ui =
1081       static_cast<PrintPreviewUI*>(web_ui()->GetController());
1082   print_preview_ui->OnCancelPendingPreviewRequest();
1083 }
1084 #endif  // !DISABLE_BASIC_PRINTING
1085
1086 void PrintPreviewHandler::HandleManagePrinters(
1087     const base::ListValue* /*args*/) {
1088   ++manage_printers_dialog_request_count_;
1089   printing::PrinterManagerDialog::ShowPrinterManagerDialog();
1090 }
1091
1092 void PrintPreviewHandler::HandlePrintWithCloudPrintDialog(
1093     const base::ListValue* args) {
1094   int page_count = 0;
1095   if (!args || !args->GetInteger(0, &page_count))
1096     return;
1097   UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToCloudPrintWebDialog",
1098                        page_count);
1099
1100   PrintWithCloudPrintDialog();
1101 }
1102
1103 void PrintPreviewHandler::HandleClosePreviewDialog(
1104     const base::ListValue* /*args*/) {
1105   ReportStats();
1106   ReportUserActionHistogram(CANCEL);
1107
1108   // Record the number of times the user requests to regenerate preview data
1109   // before cancelling.
1110   UMA_HISTOGRAM_COUNTS("PrintPreview.RegeneratePreviewRequest.BeforeCancel",
1111                        regenerate_preview_request_count_);
1112 }
1113
1114 void PrintPreviewHandler::ReportStats() {
1115   UMA_HISTOGRAM_COUNTS("PrintPreview.ManagePrinters",
1116                        manage_printers_dialog_request_count_);
1117   UMA_HISTOGRAM_COUNTS("PrintPreview.ManageCloudPrinters",
1118                        manage_cloud_printers_dialog_request_count_);
1119 }
1120
1121 void PrintPreviewHandler::GetNumberFormatAndMeasurementSystem(
1122     base::DictionaryValue* settings) {
1123
1124   // Getting the measurement system based on the locale.
1125   UErrorCode errorCode = U_ZERO_ERROR;
1126   const char* locale = g_browser_process->GetApplicationLocale().c_str();
1127   UMeasurementSystem system = ulocdata_getMeasurementSystem(locale, &errorCode);
1128   if (errorCode > U_ZERO_ERROR || system == UMS_LIMIT)
1129     system = UMS_SI;
1130
1131   // Getting the number formatting based on the locale and writing to
1132   // dictionary.
1133   settings->SetString(kNumberFormat, base::FormatDouble(123456.78, 2));
1134   settings->SetInteger(kMeasurementSystem, system);
1135 }
1136
1137 void PrintPreviewHandler::HandleGetInitialSettings(
1138     const base::ListValue* /*args*/) {
1139   // Send before SendInitialSettings to allow cloud printer auto select.
1140   SendCloudPrintEnabled();
1141   BrowserThread::PostTaskAndReplyWithResult(
1142       BrowserThread::FILE, FROM_HERE,
1143       base::Bind(&GetDefaultPrinterOnFileThread),
1144       base::Bind(&PrintPreviewHandler::SendInitialSettings,
1145                  weak_factory_.GetWeakPtr()));
1146 }
1147
1148 void PrintPreviewHandler::HandleForceOpenNewTab(const base::ListValue* args) {
1149   std::string url;
1150   if (!args->GetString(0, &url))
1151     return;
1152   Browser* browser = chrome::FindBrowserWithWebContents(GetInitiator());
1153   if (!browser)
1154     return;
1155   chrome::AddSelectedTabWithURL(browser,
1156                                 GURL(url),
1157                                 ui::PAGE_TRANSITION_LINK);
1158 }
1159
1160 void PrintPreviewHandler::SendInitialSettings(
1161     const std::string& default_printer) {
1162   PrintPreviewUI* print_preview_ui =
1163       static_cast<PrintPreviewUI*>(web_ui()->GetController());
1164
1165   base::DictionaryValue initial_settings;
1166   initial_settings.SetString(kInitiatorTitle,
1167                              print_preview_ui->initiator_title());
1168   initial_settings.SetBoolean(printing::kSettingPreviewModifiable,
1169                               print_preview_ui->source_is_modifiable());
1170   initial_settings.SetString(printing::kSettingPrinterName, default_printer);
1171   initial_settings.SetBoolean(kDocumentHasSelection,
1172                               print_preview_ui->source_has_selection());
1173   initial_settings.SetBoolean(printing::kSettingShouldPrintSelectionOnly,
1174                               print_preview_ui->print_selection_only());
1175   printing::StickySettings* sticky_settings = GetStickySettings();
1176   sticky_settings->RestoreFromPrefs(Profile::FromBrowserContext(
1177       preview_web_contents()->GetBrowserContext())->GetPrefs());
1178   if (sticky_settings->printer_app_state()) {
1179     initial_settings.SetString(kAppState,
1180                                *sticky_settings->printer_app_state());
1181   }
1182
1183   base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
1184   initial_settings.SetBoolean(kPrintAutomaticallyInKioskMode,
1185                               cmdline->HasSwitch(switches::kKioskModePrinting));
1186   initial_settings.SetBoolean(kAppKioskMode,
1187                               chrome::IsRunningInForcedAppMode());
1188 #if defined(OS_WIN)
1189   // In Win8 metro, the system print dialog can only open on the desktop.  Doing
1190   // so will cause the browser to appear hung, so we don't show the link in
1191   // metro.
1192   bool is_ash = (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_ASH);
1193   initial_settings.SetBoolean(kHidePrintWithSystemDialogLink, is_ash);
1194 #endif
1195
1196   if (print_preview_ui->source_is_modifiable())
1197     GetNumberFormatAndMeasurementSystem(&initial_settings);
1198   web_ui()->CallJavascriptFunction("setInitialSettings", initial_settings);
1199 }
1200
1201 void PrintPreviewHandler::ClosePreviewDialog() {
1202   PrintPreviewUI* print_preview_ui =
1203       static_cast<PrintPreviewUI*>(web_ui()->GetController());
1204   print_preview_ui->OnClosePrintPreviewDialog();
1205 }
1206
1207 void PrintPreviewHandler::SendAccessToken(const std::string& type,
1208                                           const std::string& access_token) {
1209   VLOG(1) << "Get getAccessToken finished";
1210   web_ui()->CallJavascriptFunction("onDidGetAccessToken",
1211                                    base::StringValue(type),
1212                                    base::StringValue(access_token));
1213 }
1214
1215 void PrintPreviewHandler::SendPrinterCapabilities(
1216     const base::DictionaryValue* settings_info) {
1217   VLOG(1) << "Get printer capabilities finished";
1218   web_ui()->CallJavascriptFunction("updateWithPrinterCapabilities",
1219                                    *settings_info);
1220 }
1221
1222 void PrintPreviewHandler::SendFailedToGetPrinterCapabilities(
1223     const std::string& printer_name) {
1224   VLOG(1) << "Get printer capabilities failed";
1225   base::StringValue printer_name_value(printer_name);
1226   web_ui()->CallJavascriptFunction("failedToGetPrinterCapabilities",
1227                                    printer_name_value);
1228 }
1229
1230 void PrintPreviewHandler::SetupPrinterList(const base::ListValue* printers) {
1231   if (!has_logged_printers_count_) {
1232     UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters", printers->GetSize());
1233     has_logged_printers_count_ = true;
1234   }
1235
1236   web_ui()->CallJavascriptFunction("setPrinters", *printers);
1237 }
1238
1239 void PrintPreviewHandler::SendCloudPrintEnabled() {
1240   Profile* profile = Profile::FromBrowserContext(
1241       preview_web_contents()->GetBrowserContext());
1242   PrefService* prefs = profile->GetPrefs();
1243   if (prefs->GetBoolean(prefs::kCloudPrintSubmitEnabled)) {
1244     base::DictionaryValue settings;
1245     settings.SetString(kCloudPrintUrl,
1246                        GURL(cloud_devices::GetCloudPrintURL()).spec());
1247     settings.SetBoolean(kAppKioskMode, chrome::IsRunningInForcedAppMode());
1248     web_ui()->CallJavascriptFunction("setUseCloudPrint", settings);
1249   }
1250 }
1251
1252 void PrintPreviewHandler::SendCloudPrintJob(const base::RefCountedBytes* data) {
1253   // BASE64 encode the job data.
1254   std::string raw_data(reinterpret_cast<const char*>(data->front()),
1255                        data->size());
1256   std::string base64_data;
1257   base::Base64Encode(raw_data, &base64_data);
1258   base::StringValue data_value(base64_data);
1259
1260   web_ui()->CallJavascriptFunction("printToCloud", data_value);
1261 }
1262
1263 WebContents* PrintPreviewHandler::GetInitiator() const {
1264   printing::PrintPreviewDialogController* dialog_controller =
1265       printing::PrintPreviewDialogController::GetInstance();
1266   if (!dialog_controller)
1267     return NULL;
1268   return dialog_controller->GetInitiator(preview_web_contents());
1269 }
1270
1271 void PrintPreviewHandler::OnPrintDialogShown() {
1272   ClosePreviewDialog();
1273 }
1274
1275 void PrintPreviewHandler::MergeSessionCompleted(
1276     const std::string& account_id,
1277     const GoogleServiceAuthError& error) {
1278   OnSigninComplete();
1279 }
1280
1281 void PrintPreviewHandler::SelectFile(const base::FilePath& default_filename) {
1282   ui::SelectFileDialog::FileTypeInfo file_type_info;
1283   file_type_info.extensions.resize(1);
1284   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("pdf"));
1285
1286   // Initializing |save_path_| if it is not already initialized.
1287   printing::StickySettings* sticky_settings = GetStickySettings();
1288   if (!sticky_settings->save_path()) {
1289     // Allowing IO operation temporarily. It is ok to do so here because
1290     // the select file dialog performs IO anyway in order to display the
1291     // folders and also it is modal.
1292     base::ThreadRestrictions::ScopedAllowIO allow_io;
1293     base::FilePath file_path;
1294     PathService::Get(chrome::DIR_USER_DOCUMENTS, &file_path);
1295     sticky_settings->StoreSavePath(file_path);
1296     sticky_settings->SaveInPrefs(Profile::FromBrowserContext(
1297         preview_web_contents()->GetBrowserContext())->GetPrefs());
1298   }
1299
1300   select_file_dialog_ = ui::SelectFileDialog::Create(
1301       this, new ChromeSelectFilePolicy(preview_web_contents())),
1302   select_file_dialog_->SelectFile(
1303       ui::SelectFileDialog::SELECT_SAVEAS_FILE,
1304       base::string16(),
1305       sticky_settings->save_path()->Append(default_filename),
1306       &file_type_info,
1307       0,
1308       base::FilePath::StringType(),
1309       platform_util::GetTopLevel(preview_web_contents()->GetNativeView()),
1310       NULL);
1311 }
1312
1313 void PrintPreviewHandler::OnPrintPreviewDialogDestroyed() {
1314   WebContents* initiator = GetInitiator();
1315   if (!initiator)
1316     return;
1317
1318   printing::PrintViewManager* print_view_manager =
1319       printing::PrintViewManager::FromWebContents(initiator);
1320   print_view_manager->set_observer(NULL);
1321 }
1322
1323 void PrintPreviewHandler::OnPrintPreviewFailed() {
1324   if (reported_failed_preview_)
1325     return;
1326   reported_failed_preview_ = true;
1327   ReportUserActionHistogram(PREVIEW_FAILED);
1328 }
1329
1330 #if !defined(DISABLE_BASIC_PRINTING)
1331 void PrintPreviewHandler::ShowSystemDialog() {
1332   HandleShowSystemDialog(NULL);
1333 }
1334 #endif  // !DISABLE_BASIC_PRINTING
1335
1336 void PrintPreviewHandler::FileSelected(const base::FilePath& path,
1337                                        int index, void* params) {
1338   // Updating |save_path_| to the newly selected folder.
1339   printing::StickySettings* sticky_settings = GetStickySettings();
1340   sticky_settings->StoreSavePath(path.DirName());
1341   sticky_settings->SaveInPrefs(Profile::FromBrowserContext(
1342       preview_web_contents()->GetBrowserContext())->GetPrefs());
1343   web_ui()->CallJavascriptFunction("fileSelectionCompleted");
1344   print_to_pdf_path_ = path;
1345   PostPrintToPdfTask();
1346 }
1347
1348 void PrintPreviewHandler::PostPrintToPdfTask() {
1349   scoped_refptr<base::RefCountedBytes> data;
1350   base::string16 title;
1351   if (!GetPreviewDataAndTitle(&data, &title)) {
1352     NOTREACHED() << "Preview data was checked before file dialog.";
1353     return;
1354   }
1355   BrowserThread::PostTask(BrowserThread::FILE,
1356                           FROM_HERE,
1357                           base::Bind(&PrintToPdfCallback,
1358                                      data,
1359                                      print_to_pdf_path_,
1360                                      pdf_file_saved_closure_));
1361   print_to_pdf_path_ = base::FilePath();
1362   ClosePreviewDialog();
1363 }
1364
1365 void PrintPreviewHandler::FileSelectionCanceled(void* params) {
1366   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
1367       web_ui()->GetController());
1368   print_preview_ui->OnFileSelectionCancelled();
1369 }
1370
1371 void PrintPreviewHandler::ClearInitiatorDetails() {
1372   WebContents* initiator = GetInitiator();
1373   if (!initiator)
1374     return;
1375
1376   // We no longer require the initiator details. Remove those details associated
1377   // with the preview dialog to allow the initiator to create another preview
1378   // dialog.
1379   printing::PrintPreviewDialogController* dialog_controller =
1380       printing::PrintPreviewDialogController::GetInstance();
1381   if (dialog_controller)
1382     dialog_controller->EraseInitiatorInfo(preview_web_contents());
1383 }
1384
1385 bool PrintPreviewHandler::GetPreviewDataAndTitle(
1386     scoped_refptr<base::RefCountedBytes>* data,
1387     base::string16* title) const {
1388   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
1389       web_ui()->GetController());
1390   scoped_refptr<base::RefCountedBytes> tmp_data;
1391   print_preview_ui->GetPrintPreviewDataForIndex(
1392       printing::COMPLETE_PREVIEW_DOCUMENT_INDEX, &tmp_data);
1393
1394   if (!tmp_data.get()) {
1395     // Nothing to print, no preview available.
1396     return false;
1397   }
1398   DCHECK(tmp_data->size() && tmp_data->front());
1399
1400   *data = tmp_data;
1401   *title = print_preview_ui->initiator_title();
1402   return true;
1403 }
1404
1405 #if defined(ENABLE_SERVICE_DISCOVERY)
1406
1407 void PrintPreviewHandler::StartPrivetLister(const scoped_refptr<
1408     local_discovery::ServiceDiscoverySharedClient>& client) {
1409   if (!PrivetPrintingEnabled())
1410     return web_ui()->CallJavascriptFunction("onPrivetPrinterSearchDone");
1411
1412   Profile* profile = Profile::FromWebUI(web_ui());
1413   DCHECK(!service_discovery_client_.get() ||
1414          service_discovery_client_.get() == client.get());
1415   service_discovery_client_ = client;
1416   printer_lister_.reset(new local_discovery::PrivetLocalPrinterLister(
1417       service_discovery_client_.get(), profile->GetRequestContext(), this));
1418   printer_lister_->Start();
1419 }
1420
1421 void PrintPreviewHandler::LocalPrinterChanged(
1422     bool added,
1423     const std::string& name,
1424     bool has_local_printing,
1425     const local_discovery::DeviceDescription& description) {
1426   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
1427   if (has_local_printing ||
1428       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos)) {
1429     base::DictionaryValue info;
1430     FillPrinterDescription(name, description, has_local_printing, &info);
1431     web_ui()->CallJavascriptFunction("onPrivetPrinterChanged", info);
1432   }
1433 }
1434
1435 void PrintPreviewHandler::LocalPrinterRemoved(const std::string& name) {
1436 }
1437
1438 void PrintPreviewHandler::LocalPrinterCacheFlushed() {
1439 }
1440
1441 void PrintPreviewHandler::PrivetCapabilitiesUpdateClient(
1442     scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
1443   if (!PrivetUpdateClient(http_client.Pass()))
1444     return;
1445
1446   privet_capabilities_operation_ =
1447       privet_http_client_->CreateCapabilitiesOperation(
1448           base::Bind(&PrintPreviewHandler::OnPrivetCapabilities,
1449                      base::Unretained(this)));
1450   privet_capabilities_operation_->Start();
1451 }
1452
1453 bool PrintPreviewHandler::PrivetUpdateClient(
1454     scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
1455   if (!http_client) {
1456     SendPrivetCapabilitiesError(privet_http_resolution_->GetName());
1457     privet_http_resolution_.reset();
1458     return false;
1459   }
1460
1461   privet_local_print_operation_.reset();
1462   privet_capabilities_operation_.reset();
1463   privet_http_client_ =
1464       local_discovery::PrivetV1HTTPClient::CreateDefault(http_client.Pass());
1465
1466   privet_http_resolution_.reset();
1467
1468   return true;
1469 }
1470
1471 void PrintPreviewHandler::PrivetLocalPrintUpdateClient(
1472     std::string print_ticket,
1473     std::string capabilities,
1474     gfx::Size page_size,
1475     scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
1476   if (!PrivetUpdateClient(http_client.Pass()))
1477     return;
1478
1479   StartPrivetLocalPrint(print_ticket, capabilities, page_size);
1480 }
1481
1482 void PrintPreviewHandler::StartPrivetLocalPrint(const std::string& print_ticket,
1483                                                 const std::string& capabilities,
1484                                                 const gfx::Size& page_size) {
1485   privet_local_print_operation_ =
1486       privet_http_client_->CreateLocalPrintOperation(this);
1487
1488   privet_local_print_operation_->SetTicket(print_ticket);
1489   privet_local_print_operation_->SetCapabilities(capabilities);
1490
1491   scoped_refptr<base::RefCountedBytes> data;
1492   base::string16 title;
1493
1494   if (!GetPreviewDataAndTitle(&data, &title)) {
1495     base::FundamentalValue http_code_value(-1);
1496     web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
1497     return;
1498   }
1499
1500   privet_local_print_operation_->SetJobname(base::UTF16ToUTF8(title));
1501   privet_local_print_operation_->SetPageSize(page_size);
1502   privet_local_print_operation_->SetData(data.get());
1503
1504   Profile* profile = Profile::FromWebUI(web_ui());
1505   SigninManagerBase* signin_manager =
1506       SigninManagerFactory::GetForProfileIfExists(profile);
1507
1508   if (signin_manager) {
1509     privet_local_print_operation_->SetUsername(
1510         signin_manager->GetAuthenticatedUsername());
1511   }
1512
1513   privet_local_print_operation_->Start();
1514 }
1515
1516
1517 void PrintPreviewHandler::OnPrivetCapabilities(
1518     const base::DictionaryValue* capabilities) {
1519   std::string name = privet_capabilities_operation_->GetHTTPClient()->GetName();
1520
1521   if (!capabilities || capabilities->HasKey(local_discovery::kPrivetKeyError) ||
1522       !printer_lister_) {
1523     SendPrivetCapabilitiesError(name);
1524     return;
1525   }
1526
1527   base::DictionaryValue printer_info;
1528   const local_discovery::DeviceDescription* description =
1529       printer_lister_->GetDeviceDescription(name);
1530
1531   if (!description) {
1532     SendPrivetCapabilitiesError(name);
1533     return;
1534   }
1535
1536   FillPrinterDescription(name, *description, true, &printer_info);
1537
1538   web_ui()->CallJavascriptFunction(
1539       "onPrivetCapabilitiesSet",
1540       printer_info,
1541       *capabilities);
1542
1543   privet_capabilities_operation_.reset();
1544 }
1545
1546 void PrintPreviewHandler::SendPrivetCapabilitiesError(
1547     const std::string& device_name) {
1548   base::StringValue name_value(device_name);
1549   web_ui()->CallJavascriptFunction(
1550       "failedToGetPrivetPrinterCapabilities",
1551       name_value);
1552 }
1553
1554 void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& device_name,
1555                                                const std::string& ticket,
1556                                                const std::string& capabilities,
1557                                                const gfx::Size& page_size) {
1558   CreatePrivetHTTP(
1559       device_name,
1560       base::Bind(&PrintPreviewHandler::PrivetLocalPrintUpdateClient,
1561                  base::Unretained(this),
1562                  ticket,
1563                  capabilities,
1564                  page_size));
1565 }
1566
1567 bool PrintPreviewHandler::CreatePrivetHTTP(
1568     const std::string& name,
1569     const local_discovery::PrivetHTTPAsynchronousFactory::ResultCallback&
1570         callback) {
1571   const local_discovery::DeviceDescription* device_description =
1572       printer_lister_ ? printer_lister_->GetDeviceDescription(name) : NULL;
1573
1574   if (!device_description) {
1575     SendPrivetCapabilitiesError(name);
1576     return false;
1577   }
1578
1579   privet_http_factory_ =
1580       local_discovery::PrivetHTTPAsynchronousFactory::CreateInstance(
1581           service_discovery_client_.get(),
1582           Profile::FromWebUI(web_ui())->GetRequestContext());
1583   privet_http_resolution_ = privet_http_factory_->CreatePrivetHTTP(
1584       name, device_description->address, callback);
1585   privet_http_resolution_->Start();
1586
1587   return true;
1588 }
1589
1590 void PrintPreviewHandler::OnPrivetPrintingDone(
1591     const local_discovery::PrivetLocalPrintOperation* print_operation) {
1592   ClosePreviewDialog();
1593 }
1594
1595 void PrintPreviewHandler::OnPrivetPrintingError(
1596     const local_discovery::PrivetLocalPrintOperation* print_operation,
1597     int http_code) {
1598   base::FundamentalValue http_code_value(http_code);
1599   web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
1600 }
1601
1602 void PrintPreviewHandler::FillPrinterDescription(
1603     const std::string& name,
1604     const local_discovery::DeviceDescription& description,
1605     bool has_local_printing,
1606     base::DictionaryValue* printer_value) {
1607   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
1608
1609   printer_value->SetString("serviceName", name);
1610   printer_value->SetString("name", description.name);
1611   printer_value->SetBoolean("hasLocalPrinting", has_local_printing);
1612   printer_value->SetBoolean(
1613       "isUnregistered",
1614       description.id.empty() &&
1615       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos));
1616   printer_value->SetString("cloudID", description.id);
1617 }
1618
1619 #endif  // defined(ENABLE_SERVICE_DISCOVERY)
1620
1621 void PrintPreviewHandler::RegisterForMergeSession() {
1622   DCHECK(!reconcilor_);
1623   Profile* profile = Profile::FromWebUI(web_ui());
1624   if (switches::IsEnableAccountConsistency() && !profile->IsOffTheRecord()) {
1625     reconcilor_ = AccountReconcilorFactory::GetForProfile(profile);
1626     if (reconcilor_)
1627       reconcilor_->AddMergeSessionObserver(this);
1628   }
1629 }
1630
1631 void PrintPreviewHandler::UnregisterForMergeSession() {
1632   if (reconcilor_)
1633     reconcilor_->RemoveMergeSessionObserver(this);
1634 }
1635
1636 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
1637     const base::Closure& closure) {
1638   pdf_file_saved_closure_ = closure;
1639 }