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/google/google_util.h"
  19 #include "chrome/browser/lifetime/application_lifetime.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/cloud_devices/common/cloud_devices_urls.h"
  29 #include "components/pref_registry/pref_registry_syncable.h"
  30 #include "content/public/browser/browser_thread.h"
  31 #include "content/public/browser/navigation_controller.h"
  32 #include "content/public/browser/navigation_entry.h"
  33 #include "content/public/browser/notification_registrar.h"
  34 #include "content/public/browser/notification_source.h"
  35 #include "content/public/browser/notification_types.h"
  36 #include "content/public/browser/render_view_host.h"
  37 #include "content/public/browser/web_contents.h"
  38 #include "content/public/browser/web_contents_observer.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() 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_CURRENTLY_ON(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_CURRENTLY_ON(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_CURRENTLY_ON(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     pending_entry->SetURL(google_util::AppendGoogleLocaleParam(
 339         cloud_devices::GetCloudPrintRelativeURL("client/dialog.html")));
 340   }
 341   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
 342                  content::Source<NavigationController>(controller));
 343   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 344                  content::Source<NavigationController>(controller));
 345 }
 346
 347 void CloudPrintFlowHandler::Observe(
 348     int type,
 349     const content::NotificationSource& source,
 350     const content::NotificationDetails& details) {
 351   switch (type) {
 352     case content::NOTIFICATION_LOAD_STOP: {
 353       GURL url = web_ui()->GetWebContents()->GetURL();
 354       if (IsCloudPrintDialogUrl(url)) {
 355         // Take the opportunity to set some (minimal) additional
 356         // script permissions required for the web UI.
 357         RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost();
 358         if (rvh) {
 359           WebPreferences webkit_prefs = rvh->GetWebkitPreferences();
 360           webkit_prefs.allow_scripts_to_close_windows = true;
 361           rvh->UpdateWebkitPreferences(webkit_prefs);
 362         } else {
 363           NOTREACHED();
 364         }
 365         // Choose one or the other.  If you need to debug, bring up the
 366         // debugger.  You can then use the various chrome.send()
 367         // registrations above to kick of the various function calls,
 368         // including chrome.send("SendPrintData") in the javaScript
 369         // console and watch things happen with:
 370         // HandleShowDebugger(NULL);
 371         HandleSendPrintData(NULL);
 372       }
 373       break;
 374     }
 375   }
 376 }
 377
 378 void CloudPrintFlowHandler::HandleShowDebugger(const base::ListValue* args) {
 379   ShowDebugger();
 380 }
 381
 382 void CloudPrintFlowHandler::ShowDebugger() {
 383   if (web_ui()) {
 384     RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost();
 385     if (rvh)
 386       DevToolsWindow::OpenDevToolsWindow(rvh);
 387   }
 388 }
 389
 390 scoped_refptr<CloudPrintDataSender>
 391 CloudPrintFlowHandler::CreateCloudPrintDataSender() {
 392   DCHECK(web_ui());
 393   print_data_helper_.reset(new CloudPrintDataSenderHelper(web_ui()));
 394   scoped_refptr<CloudPrintDataSender> sender(
 395       new CloudPrintDataSender(print_data_helper_.get(),
 396                                print_job_title_,
 397                                print_ticket_,
 398                                file_type_,
 399                                data_.get()));
 400   return sender;
 401 }
 402
 403 void CloudPrintFlowHandler::HandleSendPrintData(const base::ListValue* args) {
 404   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 405   // This will cancel any ReadPrintDataFile() or SendPrintDataFile()
 406   // requests in flight (this is anticipation of when setting page
 407   // setup parameters becomes asynchronous and may be set while some
 408   // data is in flight).  Then we can clear out the print data.
 409   CancelAnyRunningTask();
 410   if (web_ui()) {
 411     print_data_sender_ = CreateCloudPrintDataSender();
 412     BrowserThread::PostTask(
 413         BrowserThread::IO, FROM_HERE,
 414         base::Bind(&CloudPrintDataSender::SendPrintData, print_data_sender_));
 415   }
 416 }
 417
 418 void CloudPrintFlowHandler::HandleSetPageParameters(
 419     const base::ListValue* args) {
 420   std::string json;
 421   bool ret = args->GetString(0, &json);
 422   if (!ret || json.empty()) {
 423     NOTREACHED() << "Empty json string";
 424     return;
 425   }
 426
 427   // These are backstop default values - 72 dpi to match the screen,
 428   // 8.5x11 inch paper with margins subtracted (1/4 inch top, left,
 429   // right and 0.56 bottom), and the min page shrink and max page
 430   // shrink values appear all over the place with no explanation.
 431
 432   // TODO(scottbyer): Get a Linux/ChromeOS edge for PrintSettings
 433   // working so that we can get the default values from there.  Fix up
 434   // PrintWebViewHelper to do the same.
 435   const int kDPI = 72;
 436   const int kWidth = static_cast<int>((8.5-0.25-0.25)*kDPI);
 437   const int kHeight = static_cast<int>((11-0.25-0.56)*kDPI);
 438   const double kMinPageShrink = 1.25;
 439   const double kMaxPageShrink = 2.0;
 440
 441   PrintMsg_Print_Params default_settings;
 442   default_settings.content_size = gfx::Size(kWidth, kHeight);
 443   default_settings.printable_area = gfx::Rect(0, 0, kWidth, kHeight);
 444   default_settings.dpi = kDPI;
 445   default_settings.min_shrink = kMinPageShrink;
 446   default_settings.max_shrink = kMaxPageShrink;
 447   default_settings.desired_dpi = kDPI;
 448   default_settings.document_cookie = 0;
 449   default_settings.selection_only = false;
 450   default_settings.preview_request_id = 0;
 451   default_settings.is_first_request = true;
 452   default_settings.print_to_pdf = false;
 453
 454   if (!GetPageSetupParameters(json, default_settings)) {
 455     NOTREACHED();
 456     return;
 457   }
 458
 459   // TODO(scottbyer) - Here is where we would kick the originating
 460   // renderer thread with these new parameters in order to get it to
 461   // re-generate the PDF data and hand it back to us.  window.print() is
 462   // currently synchronous, so there's a lot of work to do to get to
 463   // that point.
 464 }
 465
 466 void CloudPrintFlowHandler::StoreDialogClientSize() const {
 467   if (web_ui() && web_ui()->GetWebContents()) {
 468     gfx::Size size = web_ui()->GetWebContents()->GetContainerBounds().size();
 469     Profile* profile = Profile::FromWebUI(web_ui());
 470     profile->GetPrefs()->SetInteger(prefs::kCloudPrintDialogWidth,
 471                                     size.width());
 472     profile->GetPrefs()->SetInteger(prefs::kCloudPrintDialogHeight,
 473                                     size.height());
 474   }
 475 }
 476
 477 bool CloudPrintFlowHandler::IsCloudPrintDialogUrl(const GURL& url) {
 478   GURL cloud_print_url = cloud_devices::GetCloudPrintURL();
 479   return IsSimilarUrl(url, cloud_print_url);
 480 }
 481
 482 CloudPrintWebDialogDelegate::CloudPrintWebDialogDelegate(
 483     content::BrowserContext* browser_context,
 484     gfx::NativeWindow modal_parent,
 485     const base::RefCountedMemory* data,
 486     const std::string& json_arguments,
 487     const base::string16& print_job_title,
 488     const base::string16& print_ticket,
 489     const std::string& file_type)
 490     : flow_handler_(
 491           new CloudPrintFlowHandler(data, print_job_title, print_ticket,
 492                                     file_type)),
 493       modal_parent_(modal_parent),
 494       owns_flow_handler_(true),
 495       keep_alive_when_non_modal_(true) {
 496   Init(browser_context, json_arguments);
 497 }
 498
 499 // For unit testing.
 500 CloudPrintWebDialogDelegate::CloudPrintWebDialogDelegate(
 501     CloudPrintFlowHandler* flow_handler,
 502     const std::string& json_arguments)
 503     : flow_handler_(flow_handler),
 504       modal_parent_(NULL),
 505       owns_flow_handler_(true),
 506       keep_alive_when_non_modal_(false) {
 507   Init(NULL, json_arguments);
 508 }
 509
 510 // Returns the persisted width/height for the print dialog.
 511 void GetDialogWidthAndHeightFromPrefs(content::BrowserContext* browser_context,
 512                                       int* width,
 513                                       int* height) {
 514   if (!browser_context) {
 515     *width = kDefaultWidth;
 516     *height = kDefaultHeight;
 517     return;
 518   }
 519
 520   PrefService* prefs = Profile::FromBrowserContext(browser_context)->GetPrefs();
 521   *width = prefs->GetInteger(prefs::kCloudPrintDialogWidth);
 522   *height = prefs->GetInteger(prefs::kCloudPrintDialogHeight);
 523 }
 524
 525 void CloudPrintWebDialogDelegate::Init(content::BrowserContext* browser_context,
 526                                        const std::string& json_arguments) {
 527   // This information is needed to show the dialog HTML content.
 528   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 529
 530   params_.url = GURL(chrome::kChromeUICloudPrintResourcesURL);
 531   GetDialogWidthAndHeightFromPrefs(browser_context,
 532                                    &params_.width,
 533                                    &params_.height);
 534   params_.json_input = json_arguments;
 535
 536   flow_handler_->SetDialogDelegate(this);
 537   // If we're not modal we can show the dialog with no browser.
 538   // We need this to keep Chrome alive while our dialog is up.
 539   if (!modal_parent_ && keep_alive_when_non_modal_)
 540     chrome::IncrementKeepAliveCount();
 541 }
 542
 543 CloudPrintWebDialogDelegate::~CloudPrintWebDialogDelegate() {
 544   // If the flow_handler_ is about to outlive us because we don't own
 545   // it anymore, we need to have it remove its reference to us.
 546   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 547   flow_handler_->SetDialogDelegate(NULL);
 548   if (owns_flow_handler_) {
 549     delete flow_handler_;
 550   }
 551 }
 552
 553 ui::ModalType CloudPrintWebDialogDelegate::GetDialogModalType() const {
 554     return modal_parent_ ? ui::MODAL_TYPE_WINDOW : ui::MODAL_TYPE_NONE;
 555 }
 556
 557 base::string16 CloudPrintWebDialogDelegate::GetDialogTitle() const {
 558   return base::string16();
 559 }
 560
 561 GURL CloudPrintWebDialogDelegate::GetDialogContentURL() const {
 562   return params_.url;
 563 }
 564
 565 void CloudPrintWebDialogDelegate::GetWebUIMessageHandlers(
 566     std::vector<WebUIMessageHandler*>* handlers) const {
 567   handlers->push_back(flow_handler_);
 568   // We don't own flow_handler_ anymore, but it sticks around until at
 569   // least right after OnDialogClosed() is called (and this object is
 570   // destroyed).
 571   owns_flow_handler_ = false;
 572 }
 573
 574 void CloudPrintWebDialogDelegate::GetDialogSize(gfx::Size* size) const {
 575   size->set_width(params_.width);
 576   size->set_height(params_.height);
 577 }
 578
 579 std::string CloudPrintWebDialogDelegate::GetDialogArgs() const {
 580   return params_.json_input;
 581 }
 582
 583 void CloudPrintWebDialogDelegate::OnDialogClosed(
 584     const std::string& json_retval) {
 585   // Get the final dialog size and store it.
 586   flow_handler_->StoreDialogClientSize();
 587
 588   // If we're modal we can show the dialog with no browser.
 589   // End the keep-alive so that Chrome can exit.
 590   if (!modal_parent_ && keep_alive_when_non_modal_) {
 591     // Post to prevent recursive call tho this function.
 592     base::MessageLoop::current()->PostTask(
 593         FROM_HERE, base::Bind(&chrome::DecrementKeepAliveCount));
 594   }
 595   delete this;
 596 }
 597
 598 void CloudPrintWebDialogDelegate::OnCloseContents(WebContents* source,
 599                                                   bool* out_close_dialog) {
 600   if (out_close_dialog)
 601     *out_close_dialog = true;
 602 }
 603
 604 bool CloudPrintWebDialogDelegate::ShouldShowDialogTitle() const {
 605   return false;
 606 }
 607
 608 bool CloudPrintWebDialogDelegate::HandleContextMenu(
 609     const content::ContextMenuParams& params) {
 610   return true;
 611 }
 612
 613 // Called from the UI thread, starts up the dialog.
 614 void CreateDialogImpl(content::BrowserContext* browser_context,
 615                       gfx::NativeWindow modal_parent,
 616                       const base::RefCountedMemory* data,
 617                       const base::string16& print_job_title,
 618                       const base::string16& print_ticket,
 619                       const std::string& file_type) {
 620   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 621   WebDialogDelegate* dialog_delegate =
 622       new internal_cloud_print_helpers::CloudPrintWebDialogDelegate(
 623           browser_context, modal_parent, data, std::string(), print_job_title,
 624           print_ticket, file_type);
 625 #if defined(OS_WIN)
 626   gfx::NativeWindow window =
 627 #endif
 628       chrome::ShowWebDialog(modal_parent,
 629                             Profile::FromBrowserContext(browser_context),
 630                             dialog_delegate);
 631 #if defined(OS_WIN)
 632   if (window) {
 633     HWND dialog_handle;
 634 #if defined(USE_AURA)
 635     dialog_handle = window->GetHost()->GetAcceleratedWidget();
 636 #else
 637     dialog_handle = window;
 638 #endif
 639     if (::GetForegroundWindow() != dialog_handle) {
 640       ui::ForegroundHelper::SetForeground(dialog_handle);
 641     }
 642   }
 643 #endif
 644 }
 645
 646 void CreateDialogForFileImpl(content::BrowserContext* browser_context,
 647                              gfx::NativeWindow modal_parent,
 648                              const base::FilePath& path_to_file,
 649                              const base::string16& print_job_title,
 650                              const base::string16& print_ticket,
 651                              const std::string& file_type) {
 652   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 653   scoped_refptr<base::RefCountedMemory> data;
 654   int64 file_size = 0;
 655   if (base::GetFileSize(path_to_file, &file_size) && file_size != 0) {
 656     std::string file_data;
 657     if (file_size < kuint32max) {
 658       file_data.reserve(static_cast<unsigned int>(file_size));
 659     } else {
 660       DLOG(WARNING) << " print data file too large to reserve space";
 661     }
 662     if (base::ReadFileToString(path_to_file, &file_data)) {
 663       data = base::RefCountedString::TakeString(&file_data);
 664     }
 665   }
 666   // Proceed even for empty data to simplify testing.
 667   BrowserThread::PostTask(
 668       BrowserThread::UI, FROM_HERE,
 669       base::Bind(&print_dialog_cloud::CreatePrintDialogForBytes,
 670                  browser_context, modal_parent, data, print_job_title,
 671                  print_ticket, file_type));
 672   base::DeleteFile(path_to_file, false);
 673 }
 674
 675 }  // namespace internal_cloud_print_helpers
 676
 677 namespace print_dialog_cloud {
 678
 679 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 680   registry->RegisterIntegerPref(
 681       prefs::kCloudPrintDialogWidth,
 682       kDefaultWidth,
 683       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 684   registry->RegisterIntegerPref(
 685       prefs::kCloudPrintDialogHeight,
 686       kDefaultHeight,
 687       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 688 }
 689
 690 // Called on the FILE or UI thread.  This is the main entry point into creating
 691 // the dialog.
 692
 693 void CreatePrintDialogForFile(content::BrowserContext* browser_context,
 694                               gfx::NativeWindow modal_parent,
 695                               const base::FilePath& path_to_file,
 696                               const base::string16& print_job_title,
 697                               const base::string16& print_ticket,
 698                               const std::string& file_type) {
 699   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE) ||
 700          BrowserThread::CurrentlyOn(BrowserThread::UI));
 701   BrowserThread::PostTask(
 702       BrowserThread::FILE, FROM_HERE,
 703       base::Bind(&internal_cloud_print_helpers::CreateDialogForFileImpl,
 704                  browser_context, modal_parent, path_to_file, print_job_title,
 705                  print_ticket, file_type));
 706 }
 707
 708 void CreateCloudPrintSigninTab(Browser* browser,
 709                                bool add_account,
 710                                const base::Closure& callback) {
 711   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 712   GURL url = add_account ? cloud_devices::GetCloudPrintAddAccountURL()
 713                          : cloud_devices::GetCloudPrintSigninURL();
 714   content::WebContents* web_contents = browser->OpenURL(
 715       content::OpenURLParams(google_util::AppendGoogleLocaleParam(url),
 716                              content::Referrer(),
 717                              NEW_FOREGROUND_TAB,
 718                              content::PAGE_TRANSITION_AUTO_BOOKMARK,
 719                              false));
 720   new SignInObserver(web_contents, cloud_devices::GetCloudPrintURL(), callback);
 721 }
 722
 723 void CreatePrintDialogForBytes(content::BrowserContext* browser_context,
 724                                gfx::NativeWindow modal_parent,
 725                                const base::RefCountedMemory* data,
 726                                const base::string16& print_job_title,
 727                                const base::string16& print_ticket,
 728                                const std::string& file_type) {
 729   internal_cloud_print_helpers::CreateDialogImpl(browser_context, modal_parent,
 730                                                  data, print_job_title,
 731                                                  print_ticket, file_type);
 732 }
 733
 734 bool CreatePrintDialogFromCommandLine(Profile* profile,
 735                                       const CommandLine& command_line) {
 736   DCHECK(command_line.HasSwitch(switches::kCloudPrintFile));
 737   if (!command_line.GetSwitchValuePath(switches::kCloudPrintFile).empty()) {
 738     base::FilePath cloud_print_file;
 739     cloud_print_file =
 740         command_line.GetSwitchValuePath(switches::kCloudPrintFile);
 741     if (!cloud_print_file.empty()) {
 742       base::string16 print_job_title;
 743       base::string16 print_job_print_ticket;
 744       if (command_line.HasSwitch(switches::kCloudPrintJobTitle)) {
 745         print_job_title =
 746           internal_cloud_print_helpers::GetSwitchValueString16(
 747               command_line, switches::kCloudPrintJobTitle);
 748       }
 749       if (command_line.HasSwitch(switches::kCloudPrintPrintTicket)) {
 750         print_job_print_ticket =
 751           internal_cloud_print_helpers::GetSwitchValueString16(
 752               command_line, switches::kCloudPrintPrintTicket);
 753       }
 754       std::string file_type = "application/pdf";
 755       if (command_line.HasSwitch(switches::kCloudPrintFileType)) {
 756         file_type = command_line.GetSwitchValueASCII(
 757             switches::kCloudPrintFileType);
 758       }
 759
 760       print_dialog_cloud::CreatePrintDialogForFile(profile, NULL,
 761           cloud_print_file, print_job_title, print_job_print_ticket, file_type);
 762       return true;
 763     }
 764   }
 765   return false;
 766 }
 767
 768 }  // namespace print_dialog_cloud