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
113using content::BrowserThread;
114using content::NavigationController;
115using content::NavigationEntry;
116using content::RenderViewHost;
117using content::WebContents;
118using content::WebPreferences;
119using content::WebUIMessageHandler;
120using ui::WebDialogDelegate;
121
122namespace {
123
124const int kDefaultWidth = 912;
125const int kDefaultHeight = 633;
126
127bool 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
133class 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
176namespace internal_cloud_print_helpers {
177
178// From the JSON parsed value, get the entries for the page setup
179// parameters.
180bool 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
201base::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
214void 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.
224void 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
231CloudPrintDataSender::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
244CloudPrintDataSender::~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
254void 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
284CloudPrintFlowHandler::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
296CloudPrintFlowHandler::~CloudPrintFlowHandler() {
297  // This will also cancel any task in flight.
298  CancelAnyRunningTask();
299}
300
301
302void 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.
314void 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
322void 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
352void 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
385void CloudPrintFlowHandler::HandleShowDebugger(const base::ListValue* args) {
386  ShowDebugger();
387}
388
389void 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
397scoped_refptr<CloudPrintDataSender>
398CloudPrintFlowHandler::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
410void 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
425void 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
473void 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
484bool CloudPrintFlowHandler::IsCloudPrintDialogUrl(const GURL& url) {
485  GURL cloud_print_url = cloud_devices::GetCloudPrintURL();
486  return IsSimilarUrl(url, cloud_print_url);
487}
488
489CloudPrintWebDialogDelegate::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.
507CloudPrintWebDialogDelegate::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.
518void 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
532void 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
550CloudPrintWebDialogDelegate::~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
560ui::ModalType CloudPrintWebDialogDelegate::GetDialogModalType() const {
561    return modal_parent_ ? ui::MODAL_TYPE_WINDOW : ui::MODAL_TYPE_NONE;
562}
563
564base::string16 CloudPrintWebDialogDelegate::GetDialogTitle() const {
565  return base::string16();
566}
567
568GURL CloudPrintWebDialogDelegate::GetDialogContentURL() const {
569  return params_.url;
570}
571
572void 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
581void CloudPrintWebDialogDelegate::GetDialogSize(gfx::Size* size) const {
582  size->set_width(params_.width);
583  size->set_height(params_.height);
584}
585
586std::string CloudPrintWebDialogDelegate::GetDialogArgs() const {
587  return params_.json_input;
588}
589
590void 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
605void CloudPrintWebDialogDelegate::OnCloseContents(WebContents* source,
606                                                  bool* out_close_dialog) {
607  if (out_close_dialog)
608    *out_close_dialog = true;
609}
610
611bool CloudPrintWebDialogDelegate::ShouldShowDialogTitle() const {
612  return false;
613}
614
615bool CloudPrintWebDialogDelegate::HandleContextMenu(
616    const content::ContextMenuParams& params) {
617  return true;
618}
619
620// Called from the UI thread, starts up the dialog.
621void 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
653void 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
684namespace print_dialog_cloud {
685
686void 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
700void 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
715void 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
741void 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
752bool 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
787