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