chrome/browser/printing/print_dialog_cloud.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/printing/print_dialog_cloud.h"
   6
   7
   8 #include "base/base64.h"
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/command_line.h"
  12 #include "base/file_util.h"
  13 #include "base/json/json_reader.h"
  14 #include "base/prefs/pref_service.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/values.h"
  17 #include "chrome/browser/devtools/devtools_window.h"
  18 #include "chrome/browser/lifetime/application_lifetime.h"
  19 #include "chrome/browser/printing/cloud_print/cloud_print_url.h"
  20 #include "chrome/browser/printing/print_dialog_cloud_internal.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/ui/browser.h"
  23 #include "chrome/browser/ui/browser_dialogs.h"
  24 #include "chrome/common/chrome_switches.h"
  25 #include "chrome/common/pref_names.h"
  26 #include "chrome/common/print_messages.h"
  27 #include "chrome/common/url_constants.h"
  28 #include "components/user_prefs/pref_registry_syncable.h"
  29 #include "content/public/browser/browser_thread.h"
  30 #include "content/public/browser/navigation_controller.h"
  31 #include "content/public/browser/navigation_entry.h"
  32 #include "content/public/browser/notification_registrar.h"
  33 #include "content/public/browser/notification_source.h"
  34 #include "content/public/browser/notification_types.h"
  35 #include "content/public/browser/render_view_host.h"
  36 #include "content/public/browser/web_contents.h"
  37 #include "content/public/browser/web_contents_observer.h"
  38 #include "content/public/browser/web_contents_view.h"
  39 #include "content/public/browser/web_ui.h"
  40 #include "content/public/common/frame_navigate_params.h"
  41 #include "webkit/common/webpreferences.h"
  42
  43 #if defined(USE_AURA)
  44 #include "ui/aura/window.h"
  45 #include "ui/aura/window_tree_host.h"
  46 #endif
  47
  48 #if defined(OS_WIN)
  49 #include "ui/base/win/foreground_helper.h"
  50 #endif
  51
  52 // This module implements the UI support in Chrome for cloud printing.
  53 // This means hosting a dialog containing HTML/JavaScript and using
  54 // the published cloud print user interface integration APIs to get
  55 // page setup settings from the dialog contents and provide the
  56 // generated print data to the dialog contents for uploading to the
  57 // cloud print service.
  58
  59 // Currently, the flow between these classes is as follows:
  60
  61 // PrintDialogCloud::CreatePrintDialogForFile is called from
  62 // resource_message_filter_gtk.cc once the renderer has informed the
  63 // renderer host that print data generation into the renderer host provided
  64 // temp file has been completed.  That call is on the FILE thread.
  65 // That, in turn, hops over to the UI thread to create an instance of
  66 // PrintDialogCloud.
  67
  68 // The constructor for PrintDialogCloud creates a
  69 // CloudPrintWebDialogDelegate and asks the current active browser to
  70 // show an HTML dialog using that class as the delegate. That class
  71 // hands in the kChromeUICloudPrintResourcesURL as the URL to visit.  That is
  72 // recognized by the GetWebUIFactoryFunction as a signal to create an
  73 // ExternalWebDialogUI.
  74
  75 // CloudPrintWebDialogDelegate also temporarily owns a
  76 // CloudPrintFlowHandler, a class which is responsible for the actual
  77 // interactions with the dialog contents, including handing in the
  78 // print data and getting any page setup parameters that the dialog
  79 // contents provides.  As part of bringing up the dialog,
  80 // WebDialogUI::RenderViewCreated is called (an override of
  81 // WebUI::RenderViewCreated).  That routine, in turn, calls the
  82 // delegate's GetWebUIMessageHandlers routine, at which point the
  83 // ownership of the CloudPrintFlowHandler is handed over.  A pointer
  84 // to the flow handler is kept to facilitate communication back and
  85 // forth between the two classes.
  86
  87 // The WebUI continues dialog bring-up, calling
  88 // CloudPrintFlowHandler::RegisterMessages.  This is where the
  89 // additional object model capabilities are registered for the dialog
  90 // contents to use.  It is also at this time that capabilities for the
  91 // dialog contents are adjusted to allow the dialog contents to close
  92 // the window.  In addition, the pending URL is redirected to the
  93 // actual cloud print service URL.  The flow controller also registers
  94 // for notification of when the dialog contents finish loading, which
  95 // is currently used to send the data to the dialog contents.
  96
  97 // In order to send the data to the dialog contents, the flow
  98 // handler uses a CloudPrintDataSender.  It creates one, letting it
  99 // know the name of the temporary file containing the data, and
 100 // posts the task of reading the file
 101 // (CloudPrintDataSender::ReadPrintDataFile) to the file thread.  That
 102 // routine reads in the file, and then hops over to the IO thread to
 103 // send that data to the dialog contents.
 104
 105 // When the dialog contents are finished (by either being cancelled or
 106 // hitting the print button), the delegate is notified, and responds
 107 // that the dialog should be closed, at which point things are torn
 108 // down and released.
 109
 110 using content::BrowserThread;
 111 using content::NavigationController;
 112 using content::NavigationEntry;
 113 using content::RenderViewHost;
 114 using content::WebContents;
 115 using content::WebUIMessageHandler;
 116 using ui::WebDialogDelegate;
 117
 118 namespace {
 119
 120 const int kDefaultWidth = 912;
 121 const int kDefaultHeight = 633;
 122
 123 bool IsSimilarUrl(const GURL& url, const GURL& cloud_print_url) {
 124   return url.host() == cloud_print_url.host() &&
 125          StartsWithASCII(url.path(), cloud_print_url.path(), false) &&
 126          url.scheme() == cloud_print_url.scheme();
 127 }
 128
 129 class SignInObserver : public content::WebContentsObserver {
 130  public:
 131   SignInObserver(content::WebContents* web_contents,
 132                  GURL cloud_print_url,
 133                  const base::Closure& callback)
 134       : WebContentsObserver(web_contents),
 135         cloud_print_url_(cloud_print_url),
 136         callback_(callback),
 137         weak_ptr_factory_(this) {
 138   }
 139
 140  private:
 141   // Overridden from content::WebContentsObserver:
 142   virtual void DidNavigateMainFrame(
 143       const content::LoadCommittedDetails& details,
 144       const content::FrameNavigateParams& params) OVERRIDE {
 145     if (IsSimilarUrl(params.url, cloud_print_url_)) {
 146       base::MessageLoop::current()->PostTask(
 147           FROM_HERE,
 148           base::Bind(&SignInObserver::OnSignIn,
 149                      weak_ptr_factory_.GetWeakPtr()));
 150     }
 151   }
 152
 153   virtual void WebContentsDestroyed(WebContents* web_contents) OVERRIDE {
 154     delete this;
 155   }
 156
 157   void OnSignIn() {
 158     callback_.Run();
 159     if (web_contents())
 160       web_contents()->Close();
 161   }
 162
 163   GURL cloud_print_url_;
 164   base::Closure callback_;
 165   base::WeakPtrFactory<SignInObserver> weak_ptr_factory_;
 166
 167   DISALLOW_COPY_AND_ASSIGN(SignInObserver);
 168 };
 169
 170 }  // namespace
 171
 172 namespace internal_cloud_print_helpers {
 173
 174 // From the JSON parsed value, get the entries for the page setup
 175 // parameters.
 176 bool GetPageSetupParameters(const std::string& json,
 177                             PrintMsg_Print_Params& parameters) {
 178   scoped_ptr<base::Value> parsed_value(base::JSONReader::Read(json));
 179   DLOG_IF(ERROR, (!parsed_value.get() ||
 180                   !parsed_value->IsType(base::Value::TYPE_DICTIONARY)))
 181       << "PageSetup call didn't have expected contents";
 182   if (!parsed_value.get() ||
 183       !parsed_value->IsType(base::Value::TYPE_DICTIONARY)) {
 184     return false;
 185   }
 186
 187   bool result = true;
 188   base::DictionaryValue* params =
 189       static_cast<base::DictionaryValue*>(parsed_value.get());
 190   result &= params->GetDouble("dpi", &parameters.dpi);
 191   result &= params->GetDouble("min_shrink", &parameters.min_shrink);
 192   result &= params->GetDouble("max_shrink", &parameters.max_shrink);
 193   result &= params->GetBoolean("selection_only", &parameters.selection_only);
 194   return result;
 195 }
 196
 197 base::string16 GetSwitchValueString16(const CommandLine& command_line,
 198                                       const char* switchName) {
 199 #if defined(OS_WIN)
 200   return command_line.GetSwitchValueNative(switchName);
 201 #elif defined(OS_POSIX)
 202   // POSIX Command line string types are different.
 203   CommandLine::StringType native_switch_val;
 204   native_switch_val = command_line.GetSwitchValueASCII(switchName);
 205   // Convert the ASCII string to UTF16 to prepare to pass.
 206   return base::ASCIIToUTF16(native_switch_val);
 207 #endif
 208 }
 209
 210 void CloudPrintDataSenderHelper::CallJavascriptFunction(
 211     const std::string& function_name,
 212     const base::Value& arg1,
 213     const base::Value& arg2) {
 214   web_ui_->CallJavascriptFunction(function_name, arg1, arg2);
 215 }
 216
 217 // Clears out the pointer we're using to communicate.  Either routine is
 218 // potentially expensive enough that stopping whatever is in progress
 219 // is worth it.
 220 void CloudPrintDataSender::CancelPrintDataFile() {
 221   base::AutoLock lock(lock_);
 222   // We don't own helper, it was passed in to us, so no need to
 223   // delete, just let it go.
 224   helper_ = NULL;
 225 }
 226
 227 CloudPrintDataSender::CloudPrintDataSender(
 228     CloudPrintDataSenderHelper* helper,
 229     const base::string16& print_job_title,
 230     const base::string16& print_ticket,
 231     const std::string& file_type,
 232     const base::RefCountedMemory* data)
 233     : helper_(helper),
 234       print_job_title_(print_job_title),
 235       print_ticket_(print_ticket),
 236       file_type_(file_type),
 237       data_(data) {
 238 }
 239
 240 CloudPrintDataSender::~CloudPrintDataSender() {}
 241
 242 // We have the data in hand that needs to be pushed into the dialog
 243 // contents; do so from the IO thread.
 244
 245 // TODO(scottbyer): If the print data ends up being larger than the
 246 // upload limit (currently 10MB), what we need to do is upload that
 247 // large data to google docs and set the URL in the printing
 248 // JavaScript to that location, and make sure it gets deleted when not
 249 // needed. - 4/1/2010
 250 void CloudPrintDataSender::SendPrintData() {
 251   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 252   if (!data_.get() || !data_->size())
 253     return;
 254
 255   std::string base64_data;
 256   base::Base64Encode(
 257       base::StringPiece(data_->front_as<char>(), data_->size()),
 258       &base64_data);
 259   std::string header("data:");
 260   header.append(file_type_);
 261   header.append(";base64,");
 262   base64_data.insert(0, header);
 263
 264   base::AutoLock lock(lock_);
 265   if (helper_) {
 266     base::StringValue title(print_job_title_);
 267     base::StringValue ticket(print_ticket_);
 268     // TODO(abodenha): Change Javascript call to pass in print ticket
 269     // after server side support is added. Add test for it.
 270
 271     // Send the print data to the dialog contents.  The JavaScript
 272     // function is a preliminary API for prototyping purposes and is
 273     // subject to change.
 274     helper_->CallJavascriptFunction(
 275         "printApp._printDataUrl", base::StringValue(base64_data), title);
 276   }
 277 }
 278
 279
 280 CloudPrintFlowHandler::CloudPrintFlowHandler(
 281     const base::RefCountedMemory* data,
 282     const base::string16& print_job_title,
 283     const base::string16& print_ticket,
 284     const std::string& file_type)
 285     : dialog_delegate_(NULL),
 286       data_(data),
 287       print_job_title_(print_job_title),
 288       print_ticket_(print_ticket),
 289       file_type_(file_type) {
 290 }
 291
 292 CloudPrintFlowHandler::~CloudPrintFlowHandler() {
 293   // This will also cancel any task in flight.
 294   CancelAnyRunningTask();
 295 }
 296
 297
 298 void CloudPrintFlowHandler::SetDialogDelegate(
 299     CloudPrintWebDialogDelegate* delegate) {
 300   // Even if setting a new WebUI, it means any previous task needs
 301   // to be canceled, its now invalid.
 302   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 303   CancelAnyRunningTask();
 304   dialog_delegate_ = delegate;
 305 }
 306
 307 // Cancels any print data sender we have in flight and removes our
 308 // reference to it, so when the task that is calling it finishes and
 309 // removes its reference, it goes away.
 310 void CloudPrintFlowHandler::CancelAnyRunningTask() {
 311   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 312   if (print_data_sender_.get()) {
 313     print_data_sender_->CancelPrintDataFile();
 314     print_data_sender_ = NULL;
 315   }
 316 }
 317
 318 void CloudPrintFlowHandler::RegisterMessages() {
 319   // TODO(scottbyer) - This is where we will register messages for the
 320   // UI JS to use.  Needed: Call to update page setup parameters.
 321   web_ui()->RegisterMessageCallback("ShowDebugger",
 322       base::Bind(&CloudPrintFlowHandler::HandleShowDebugger,
 323                  base::Unretained(this)));
 324   web_ui()->RegisterMessageCallback("SendPrintData",
 325       base::Bind(&CloudPrintFlowHandler::HandleSendPrintData,
 326                  base::Unretained(this)));
 327   web_ui()->RegisterMessageCallback("SetPageParameters",
 328       base::Bind(&CloudPrintFlowHandler::HandleSetPageParameters,
 329                  base::Unretained(this)));
 330
 331   // Register for appropriate notifications, and re-direct the URL
 332   // to the real server URL, now that we've gotten an HTML dialog
 333   // going.
 334   NavigationController* controller =
 335       &web_ui()->GetWebContents()->GetController();
 336   NavigationEntry* pending_entry = controller->GetPendingEntry();
 337   if (pending_entry) {
 338     Profile* profile = Profile::FromWebUI(web_ui());
 339     pending_entry->SetURL(
 340         CloudPrintURL(profile).GetCloudPrintServiceDialogURL());
 341   }
 342   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
 343                  content::Source<NavigationController>(controller));
 344   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 345                  content::Source<NavigationController>(controller));
 346 }
 347
 348 void CloudPrintFlowHandler::Observe(
 349     int type,
 350     const content::NotificationSource& source,
 351     const content::NotificationDetails& details) {
 352   switch (type) {
 353     case content::NOTIFICATION_LOAD_STOP: {
 354       GURL url = web_ui()->GetWebContents()->GetURL();
 355       if (IsCloudPrintDialogUrl(url)) {
 356         // Take the opportunity to set some (minimal) additional
 357         // script permissions required for the web UI.
 358         RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost();
 359         if (rvh) {
 360           WebPreferences webkit_prefs = rvh->GetWebkitPreferences();
 361           webkit_prefs.allow_scripts_to_close_windows = true;
 362           rvh->UpdateWebkitPreferences(webkit_prefs);
 363         } else {
 364           NOTREACHED();
 365         }
 366         // Choose one or the other.  If you need to debug, bring up the
 367         // debugger.  You can then use the various chrome.send()
 368         // registrations above to kick of the various function calls,
 369         // including chrome.send("SendPrintData") in the javaScript
 370         // console and watch things happen with:
 371         // HandleShowDebugger(NULL);
 372         HandleSendPrintData(NULL);
 373       }
 374       break;
 375     }
 376   }
 377 }
 378
 379 void CloudPrintFlowHandler::HandleShowDebugger(const base::ListValue* args) {
 380   ShowDebugger();
 381 }
 382
 383 void CloudPrintFlowHandler::ShowDebugger() {
 384   if (web_ui()) {
 385     RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost();
 386     if (rvh)
 387       DevToolsWindow::OpenDevToolsWindow(rvh);
 388   }
 389 }
 390
 391 scoped_refptr<CloudPrintDataSender>
 392 CloudPrintFlowHandler::CreateCloudPrintDataSender() {
 393   DCHECK(web_ui());
 394   print_data_helper_.reset(new CloudPrintDataSenderHelper(web_ui()));
 395   scoped_refptr<CloudPrintDataSender> sender(
 396       new CloudPrintDataSender(print_data_helper_.get(),
 397                                print_job_title_,
 398                                print_ticket_,
 399                                file_type_,
 400                                data_.get()));
 401   return sender;
 402 }
 403
 404 void CloudPrintFlowHandler::HandleSendPrintData(const base::ListValue* args) {
 405   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 406   // This will cancel any ReadPrintDataFile() or SendPrintDataFile()
 407   // requests in flight (this is anticipation of when setting page
 408   // setup parameters becomes asynchronous and may be set while some
 409   // data is in flight).  Then we can clear out the print data.
 410   CancelAnyRunningTask();
 411   if (web_ui()) {
 412     print_data_sender_ = CreateCloudPrintDataSender();
 413     BrowserThread::PostTask(
 414         BrowserThread::IO, FROM_HERE,
 415         base::Bind(&CloudPrintDataSender::SendPrintData, print_data_sender_));
 416   }
 417 }
 418
 419 void CloudPrintFlowHandler::HandleSetPageParameters(
 420     const base::ListValue* args) {
 421   std::string json;
 422   bool ret = args->GetString(0, &json);
 423   if (!ret || json.empty()) {
 424     NOTREACHED() << "Empty json string";
 425     return;
 426   }
 427
 428   // These are backstop default values - 72 dpi to match the screen,
 429   // 8.5x11 inch paper with margins subtracted (1/4 inch top, left,
 430   // right and 0.56 bottom), and the min page shrink and max page
 431   // shrink values appear all over the place with no explanation.
 432
 433   // TODO(scottbyer): Get a Linux/ChromeOS edge for PrintSettings
 434   // working so that we can get the default values from there.  Fix up
 435   // PrintWebViewHelper to do the same.
 436   const int kDPI = 72;
 437   const int kWidth = static_cast<int>((8.5-0.25-0.25)*kDPI);
 438   const int kHeight = static_cast<int>((11-0.25-0.56)*kDPI);
 439   const double kMinPageShrink = 1.25;
 440   const double kMaxPageShrink = 2.0;
 441
 442   PrintMsg_Print_Params default_settings;
 443   default_settings.content_size = gfx::Size(kWidth, kHeight);
 444   default_settings.printable_area = gfx::Rect(0, 0, kWidth, kHeight);
 445   default_settings.dpi = kDPI;
 446   default_settings.min_shrink = kMinPageShrink;
 447   default_settings.max_shrink = kMaxPageShrink;
 448   default_settings.desired_dpi = kDPI;
 449   default_settings.document_cookie = 0;
 450   default_settings.selection_only = false;
 451   default_settings.preview_request_id = 0;
 452   default_settings.is_first_request = true;
 453   default_settings.print_to_pdf = false;
 454
 455   if (!GetPageSetupParameters(json, default_settings)) {
 456     NOTREACHED();
 457     return;
 458   }
 459
 460   // TODO(scottbyer) - Here is where we would kick the originating
 461   // renderer thread with these new parameters in order to get it to
 462   // re-generate the PDF data and hand it back to us.  window.print() is
 463   // currently synchronous, so there's a lot of work to do to get to
 464   // that point.
 465 }
 466
 467 void CloudPrintFlowHandler::StoreDialogClientSize() const {
 468   if (web_ui() && web_ui()->GetWebContents() &&
 469       web_ui()->GetWebContents()->GetView()) {
 470     gfx::Size size = web_ui()->GetWebContents()->GetView()->GetContainerSize();
 471     Profile* profile = Profile::FromWebUI(web_ui());
 472     profile->GetPrefs()->SetInteger(prefs::kCloudPrintDialogWidth,
 473                                     size.width());
 474     profile->GetPrefs()->SetInteger(prefs::kCloudPrintDialogHeight,
 475                                     size.height());
 476   }
 477 }
 478
 479 bool CloudPrintFlowHandler::IsCloudPrintDialogUrl(const GURL& url) {
 480   GURL cloud_print_url =
 481       CloudPrintURL(Profile::FromWebUI(web_ui())).GetCloudPrintServiceURL();
 482   return IsSimilarUrl(url, cloud_print_url);
 483 }
 484
 485 CloudPrintWebDialogDelegate::CloudPrintWebDialogDelegate(
 486     content::BrowserContext* browser_context,
 487     gfx::NativeWindow modal_parent,
 488     const base::RefCountedMemory* data,
 489     const std::string& json_arguments,
 490     const base::string16& print_job_title,
 491     const base::string16& print_ticket,
 492     const std::string& file_type)
 493     : flow_handler_(
 494           new CloudPrintFlowHandler(data, print_job_title, print_ticket,
 495                                     file_type)),
 496       modal_parent_(modal_parent),
 497       owns_flow_handler_(true),
 498       keep_alive_when_non_modal_(true) {
 499   Init(browser_context, json_arguments);
 500 }
 501
 502 // For unit testing.
 503 CloudPrintWebDialogDelegate::CloudPrintWebDialogDelegate(
 504     CloudPrintFlowHandler* flow_handler,
 505     const std::string& json_arguments)
 506     : flow_handler_(flow_handler),
 507       modal_parent_(NULL),
 508       owns_flow_handler_(true),
 509       keep_alive_when_non_modal_(false) {
 510   Init(NULL, json_arguments);
 511 }
 512
 513 // Returns the persisted width/height for the print dialog.
 514 void GetDialogWidthAndHeightFromPrefs(content::BrowserContext* browser_context,
 515                                       int* width,
 516                                       int* height) {
 517   if (!browser_context) {
 518     *width = kDefaultWidth;
 519     *height = kDefaultHeight;
 520     return;
 521   }
 522
 523   PrefService* prefs = Profile::FromBrowserContext(browser_context)->GetPrefs();
 524   *width = prefs->GetInteger(prefs::kCloudPrintDialogWidth);
 525   *height = prefs->GetInteger(prefs::kCloudPrintDialogHeight);
 526 }
 527
 528 void CloudPrintWebDialogDelegate::Init(content::BrowserContext* browser_context,
 529                                        const std::string& json_arguments) {
 530   // This information is needed to show the dialog HTML content.
 531   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 532
 533   params_.url = GURL(chrome::kChromeUICloudPrintResourcesURL);
 534   GetDialogWidthAndHeightFromPrefs(browser_context,
 535                                    &params_.width,
 536                                    &params_.height);
 537   params_.json_input = json_arguments;
 538
 539   flow_handler_->SetDialogDelegate(this);
 540   // If we're not modal we can show the dialog with no browser.
 541   // We need this to keep Chrome alive while our dialog is up.
 542   if (!modal_parent_ && keep_alive_when_non_modal_)
 543     chrome::IncrementKeepAliveCount();
 544 }
 545
 546 CloudPrintWebDialogDelegate::~CloudPrintWebDialogDelegate() {
 547   // If the flow_handler_ is about to outlive us because we don't own
 548   // it anymore, we need to have it remove its reference to us.
 549   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 550   flow_handler_->SetDialogDelegate(NULL);
 551   if (owns_flow_handler_) {
 552     delete flow_handler_;
 553   }
 554 }
 555
 556 ui::ModalType CloudPrintWebDialogDelegate::GetDialogModalType() const {
 557     return modal_parent_ ? ui::MODAL_TYPE_WINDOW : ui::MODAL_TYPE_NONE;
 558 }
 559
 560 base::string16 CloudPrintWebDialogDelegate::GetDialogTitle() const {
 561   return base::string16();
 562 }
 563
 564 GURL CloudPrintWebDialogDelegate::GetDialogContentURL() const {
 565   return params_.url;
 566 }
 567
 568 void CloudPrintWebDialogDelegate::GetWebUIMessageHandlers(
 569     std::vector<WebUIMessageHandler*>* handlers) const {
 570   handlers->push_back(flow_handler_);
 571   // We don't own flow_handler_ anymore, but it sticks around until at
 572   // least right after OnDialogClosed() is called (and this object is
 573   // destroyed).
 574   owns_flow_handler_ = false;
 575 }
 576
 577 void CloudPrintWebDialogDelegate::GetDialogSize(gfx::Size* size) const {
 578   size->set_width(params_.width);
 579   size->set_height(params_.height);
 580 }
 581
 582 std::string CloudPrintWebDialogDelegate::GetDialogArgs() const {
 583   return params_.json_input;
 584 }
 585
 586 void CloudPrintWebDialogDelegate::OnDialogClosed(
 587     const std::string& json_retval) {
 588   // Get the final dialog size and store it.
 589   flow_handler_->StoreDialogClientSize();
 590
 591   // If we're modal we can show the dialog with no browser.
 592   // End the keep-alive so that Chrome can exit.
 593   if (!modal_parent_ && keep_alive_when_non_modal_) {
 594     // Post to prevent recursive call tho this function.
 595     base::MessageLoop::current()->PostTask(
 596         FROM_HERE, base::Bind(&chrome::DecrementKeepAliveCount));
 597   }
 598   delete this;
 599 }
 600
 601 void CloudPrintWebDialogDelegate::OnCloseContents(WebContents* source,
 602                                                   bool* out_close_dialog) {
 603   if (out_close_dialog)
 604     *out_close_dialog = true;
 605 }
 606
 607 bool CloudPrintWebDialogDelegate::ShouldShowDialogTitle() const {
 608   return false;
 609 }
 610
 611 bool CloudPrintWebDialogDelegate::HandleContextMenu(
 612     const content::ContextMenuParams& params) {
 613   return true;
 614 }
 615
 616 // Called from the UI thread, starts up the dialog.
 617 void CreateDialogImpl(content::BrowserContext* browser_context,
 618                       gfx::NativeWindow modal_parent,
 619                       const base::RefCountedMemory* data,
 620                       const base::string16& print_job_title,
 621                       const base::string16& print_ticket,
 622                       const std::string& file_type) {
 623   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 624   WebDialogDelegate* dialog_delegate =
 625       new internal_cloud_print_helpers::CloudPrintWebDialogDelegate(
 626           browser_context, modal_parent, data, std::string(), print_job_title,
 627           print_ticket, file_type);
 628 #if defined(OS_WIN)
 629   gfx::NativeWindow window =
 630 #endif
 631       chrome::ShowWebDialog(modal_parent,
 632                             Profile::FromBrowserContext(browser_context),
 633                             dialog_delegate);
 634 #if defined(OS_WIN)
 635   if (window) {
 636     HWND dialog_handle;
 637 #if defined(USE_AURA)
 638     dialog_handle = window->GetHost()->GetAcceleratedWidget();
 639 #else
 640     dialog_handle = window;
 641 #endif
 642     if (::GetForegroundWindow() != dialog_handle) {
 643       ui::ForegroundHelper::SetForeground(dialog_handle);
 644     }
 645   }
 646 #endif
 647 }
 648
 649 void CreateDialogForFileImpl(content::BrowserContext* browser_context,
 650                              gfx::NativeWindow modal_parent,
 651                              const base::FilePath& path_to_file,
 652                              const base::string16& print_job_title,
 653                              const base::string16& print_ticket,
 654                              const std::string& file_type) {
 655   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 656   scoped_refptr<base::RefCountedMemory> data;
 657   int64 file_size = 0;
 658   if (base::GetFileSize(path_to_file, &file_size) && file_size != 0) {
 659     std::string file_data;
 660     if (file_size < kuint32max) {
 661       file_data.reserve(static_cast<unsigned int>(file_size));
 662     } else {
 663       DLOG(WARNING) << " print data file too large to reserve space";
 664     }
 665     if (base::ReadFileToString(path_to_file, &file_data)) {
 666       data = base::RefCountedString::TakeString(&file_data);
 667     }
 668   }
 669   // Proceed even for empty data to simplify testing.
 670   BrowserThread::PostTask(
 671       BrowserThread::UI, FROM_HERE,
 672       base::Bind(&print_dialog_cloud::CreatePrintDialogForBytes,
 673                  browser_context, modal_parent, data, print_job_title,
 674                  print_ticket, file_type));
 675   base::DeleteFile(path_to_file, false);
 676 }
 677
 678 }  // namespace internal_cloud_print_helpers
 679
 680 namespace print_dialog_cloud {
 681
 682 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 683   registry->RegisterIntegerPref(
 684       prefs::kCloudPrintDialogWidth,
 685       kDefaultWidth,
 686       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 687   registry->RegisterIntegerPref(
 688       prefs::kCloudPrintDialogHeight,
 689       kDefaultHeight,
 690       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 691 }
 692
 693 // Called on the FILE or UI thread.  This is the main entry point into creating
 694 // the dialog.
 695
 696 void CreatePrintDialogForFile(content::BrowserContext* browser_context,
 697                               gfx::NativeWindow modal_parent,
 698                               const base::FilePath& path_to_file,
 699                               const base::string16& print_job_title,
 700                               const base::string16& print_ticket,
 701                               const std::string& file_type) {
 702   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE) ||
 703          BrowserThread::CurrentlyOn(BrowserThread::UI));
 704   BrowserThread::PostTask(
 705       BrowserThread::FILE, FROM_HERE,
 706       base::Bind(&internal_cloud_print_helpers::CreateDialogForFileImpl,
 707                  browser_context, modal_parent, path_to_file, print_job_title,
 708                  print_ticket, file_type));
 709 }
 710
 711 void CreateCloudPrintSigninTab(Browser* browser,
 712                                const base::Closure& callback) {
 713   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 714   CloudPrintURL cp_url(browser->profile());
 715   content::WebContents* web_contents =
 716       browser->OpenURL(
 717           content::OpenURLParams(cp_url.GetCloudPrintSigninURL(),
 718                                  content::Referrer(), NEW_FOREGROUND_TAB,
 719                                  content::PAGE_TRANSITION_AUTO_BOOKMARK,
 720                                  false));
 721   new SignInObserver(web_contents, cp_url.GetCloudPrintServiceURL(), callback);
 722 }
 723
 724 void CreatePrintDialogForBytes(content::BrowserContext* browser_context,
 725                                gfx::NativeWindow modal_parent,
 726                                const base::RefCountedMemory* data,
 727                                const base::string16& print_job_title,
 728                                const base::string16& print_ticket,
 729                                const std::string& file_type) {
 730   internal_cloud_print_helpers::CreateDialogImpl(browser_context, modal_parent,
 731                                                  data, print_job_title,
 732                                                  print_ticket, file_type);
 733 }
 734
 735 bool CreatePrintDialogFromCommandLine(Profile* profile,
 736                                       const CommandLine& command_line) {
 737   DCHECK(command_line.HasSwitch(switches::kCloudPrintFile));
 738   if (!command_line.GetSwitchValuePath(switches::kCloudPrintFile).empty()) {
 739     base::FilePath cloud_print_file;
 740     cloud_print_file =
 741         command_line.GetSwitchValuePath(switches::kCloudPrintFile);
 742     if (!cloud_print_file.empty()) {
 743       base::string16 print_job_title;
 744       base::string16 print_job_print_ticket;
 745       if (command_line.HasSwitch(switches::kCloudPrintJobTitle)) {
 746         print_job_title =
 747           internal_cloud_print_helpers::GetSwitchValueString16(
 748               command_line, switches::kCloudPrintJobTitle);
 749       }
 750       if (command_line.HasSwitch(switches::kCloudPrintPrintTicket)) {
 751         print_job_print_ticket =
 752           internal_cloud_print_helpers::GetSwitchValueString16(
 753               command_line, switches::kCloudPrintPrintTicket);
 754       }
 755       std::string file_type = "application/pdf";
 756       if (command_line.HasSwitch(switches::kCloudPrintFileType)) {
 757         file_type = command_line.GetSwitchValueASCII(
 758             switches::kCloudPrintFileType);
 759       }
 760
 761       print_dialog_cloud::CreatePrintDialogForFile(profile, NULL,
 762           cloud_print_file, print_job_title, print_job_print_ticket, file_type);
 763       return true;
 764     }
 765   }
 766   return false;
 767 }
 768
 769 }  // namespace print_dialog_cloud