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