WebDialogs

chrome/browser/printing/print_dialog_cloud.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/printing/print_dialog_cloud.h"
 #include "chrome/browser/printing/print_dialog_cloud_internal.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 32 matching lines @@
 #if defined(OS_WIN)
 #include "ui/base/win/foreground_helper.h"
 #endif
 
 #include "webkit/glue/webpreferences.h"
 
 #include "grit/generated_resources.h"
 
 #if defined(USE_AURA)
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/views/html_dialog_view.h"
+#include "chrome/browser/ui/views/web_dialog_view.h"
 #include "ui/aura/root_window.h"
 #include "ui/views/widget/widget.h"
 #endif
 
 // This module implements the UI support in Chrome for cloud printing.
 // This means hosting a dialog containing HTML/JavaScript and using
 // the published cloud print user interface integration APIs to get
 // page setup settings from the dialog contents and provide the
 // generated print data to the dialog contents for uploading to the
 // cloud print service.
 
 // Currently, the flow between these classes is as follows:
 
 // PrintDialogCloud::CreatePrintDialogForFile is called from
 // resource_message_filter_gtk.cc once the renderer has informed the
 // renderer host that print data generation into the renderer host provided
 // temp file has been completed.  That call is on the FILE thread.
 // That, in turn, hops over to the UI thread to create an instance of
 // PrintDialogCloud.
 
 // The constructor for PrintDialogCloud creates a
-// CloudPrintHtmlDialogDelegate and asks the current active browser to
+// CloudPrintWebDialogDelegate and asks the current active browser to
 // show an HTML dialog using that class as the delegate. That class
 // hands in the kChromeUICloudPrintResourcesURL as the URL to visit.  That is
 // recognized by the GetWebUIFactoryFunction as a signal to create an
 // ExternalHtmlDialogUI.
 
-// CloudPrintHtmlDialogDelegate also temporarily owns a
+// CloudPrintWebDialogDelegate also temporarily owns a
 // CloudPrintFlowHandler, a class which is responsible for the actual
 // interactions with the dialog contents, including handing in the
 // print data and getting any page setup parameters that the dialog
 // contents provides.  As part of bringing up the dialog,
 // HtmlDialogUI::RenderViewCreated is called (an override of
 // WebUI::RenderViewCreated).  That routine, in turn, calls the
 // delegate's GetWebUIMessageHandlers routine, at which point the
 // ownership of the CloudPrintFlowHandler is handed over.  A pointer
 // to the flow handler is kept to facilitate communication back and
 // forth between the two classes.
@@ skipping 188 matching lines @@
       callback_(callback) {
 }
 
 CloudPrintFlowHandler::~CloudPrintFlowHandler() {
   // This will also cancel any task in flight.
   CancelAnyRunningTask();
 }
 
 
 void CloudPrintFlowHandler::SetDialogDelegate(
-    CloudPrintHtmlDialogDelegate* delegate) {
+    CloudPrintWebDialogDelegate* delegate) {
   // Even if setting a new WebUI, it means any previous task needs
   // to be canceled, its now invalid.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CancelAnyRunningTask();
   dialog_delegate_ = delegate;
 }
 
 // Cancels any print data sender we have in flight and removes our
 // reference to it, so when the task that is calling it finishes and
 // removes its reference, it goes away.
@@ skipping 179 matching lines @@
       web_ui()->GetWebContents()->GetView()) {
     gfx::Size size = web_ui()->GetWebContents()->GetView()->GetContainerSize();
     Profile* profile = Profile::FromWebUI(web_ui());
     profile->GetPrefs()->SetInteger(prefs::kCloudPrintDialogWidth,
                                     size.width());
     profile->GetPrefs()->SetInteger(prefs::kCloudPrintDialogHeight,
                                     size.height());
   }
 }
 
-CloudPrintHtmlDialogDelegate::CloudPrintHtmlDialogDelegate(
+CloudPrintWebDialogDelegate::CloudPrintWebDialogDelegate(
     const FilePath& path_to_file,
     int width, int height,
     const std::string& json_arguments,
     const string16& print_job_title,
     const string16& print_ticket,
     const std::string& file_type,
     bool modal,
     bool delete_on_close,
     bool close_after_signin,
     const base::Closure& callback)
     : delete_on_close_(delete_on_close),
       flow_handler_(new CloudPrintFlowHandler(path_to_file,
                                               print_job_title,
                                               print_ticket,
                                               file_type,
                                               close_after_signin,
                                               callback)),
       modal_(modal),
       owns_flow_handler_(true),
       path_to_file_(path_to_file) {
   Init(width, height, json_arguments);
 }
 
 // For unit testing.
-CloudPrintHtmlDialogDelegate::CloudPrintHtmlDialogDelegate(
+CloudPrintWebDialogDelegate::CloudPrintWebDialogDelegate(
     CloudPrintFlowHandler* flow_handler,
     int width, int height,
     const std::string& json_arguments,
     bool modal,
     bool delete_on_close)
     : delete_on_close_(delete_on_close),
       flow_handler_(flow_handler),
       modal_(modal),
       owns_flow_handler_(true) {
   Init(width, height, json_arguments);
 }
 
-void CloudPrintHtmlDialogDelegate::Init(int width, int height,
-                                        const std::string& json_arguments) {
+void CloudPrintWebDialogDelegate::Init(int width, int height,
+                                       const std::string& json_arguments) {
   // This information is needed to show the dialog HTML content.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   params_.url = GURL(chrome::kChromeUICloudPrintResourcesURL);
   params_.height = height;
   params_.width = width;
   params_.json_input = json_arguments;
 
   flow_handler_->SetDialogDelegate(this);
   // If we're not modal we can show the dialog with no browser.
   // We need this to keep Chrome alive while our dialog is up.
   if (!modal_)
     BrowserList::StartKeepAlive();
 }
 
-CloudPrintHtmlDialogDelegate::~CloudPrintHtmlDialogDelegate() {
+CloudPrintWebDialogDelegate::~CloudPrintWebDialogDelegate() {
   // If the flow_handler_ is about to outlive us because we don't own
   // it anymore, we need to have it remove its reference to us.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   flow_handler_->SetDialogDelegate(NULL);
   if (owns_flow_handler_) {
     delete flow_handler_;
   }
 }
 
-ui::ModalType CloudPrintHtmlDialogDelegate::GetDialogModalType() const {
+ui::ModalType CloudPrintWebDialogDelegate::GetDialogModalType() const {
     return modal_ ? ui::MODAL_TYPE_WINDOW : ui::MODAL_TYPE_NONE;
 }
 
-string16 CloudPrintHtmlDialogDelegate::GetDialogTitle() const {
+string16 CloudPrintWebDialogDelegate::GetDialogTitle() const {
   return string16();
 }
 
-GURL CloudPrintHtmlDialogDelegate::GetDialogContentURL() const {
+GURL CloudPrintWebDialogDelegate::GetDialogContentURL() const {
   return params_.url;
 }
 
-void CloudPrintHtmlDialogDelegate::GetWebUIMessageHandlers(
+void CloudPrintWebDialogDelegate::GetWebUIMessageHandlers(
     std::vector<WebUIMessageHandler*>* handlers) const {
   handlers->push_back(flow_handler_);
   // We don't own flow_handler_ anymore, but it sticks around until at
   // least right after OnDialogClosed() is called (and this object is
   // destroyed).
   owns_flow_handler_ = false;
 }
 
-void CloudPrintHtmlDialogDelegate::GetDialogSize(gfx::Size* size) const {
+void CloudPrintWebDialogDelegate::GetDialogSize(gfx::Size* size) const {
   size->set_width(params_.width);
   size->set_height(params_.height);
 }
 
-std::string CloudPrintHtmlDialogDelegate::GetDialogArgs() const {
+std::string CloudPrintWebDialogDelegate::GetDialogArgs() const {
   return params_.json_input;
 }
 
-void CloudPrintHtmlDialogDelegate::OnDialogClosed(
+void CloudPrintWebDialogDelegate::OnDialogClosed(
     const std::string& json_retval) {
   // Get the final dialog size and store it.
   flow_handler_->StoreDialogClientSize();
 
   if (delete_on_close_) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&internal_cloud_print_helpers::Delete, path_to_file_));
   }
 
   // If we're modal we can show the dialog with no browser.
   // End the keep-alive so that Chrome can exit.
   if (!modal_)
     BrowserList::EndKeepAlive();
   delete this;
 }
 
-void CloudPrintHtmlDialogDelegate::OnCloseContents(WebContents* source,
-                                                   bool* out_close_dialog) {
+void CloudPrintWebDialogDelegate::OnCloseContents(WebContents* source,
+                                                  bool* out_close_dialog) {
   if (out_close_dialog)
     *out_close_dialog = true;
 }
 
-bool CloudPrintHtmlDialogDelegate::ShouldShowDialogTitle() const {
+bool CloudPrintWebDialogDelegate::ShouldShowDialogTitle() const {
   return false;
 }
 
-bool CloudPrintHtmlDialogDelegate::HandleContextMenu(
+bool CloudPrintWebDialogDelegate::HandleContextMenu(
     const content::ContextMenuParams& params) {
   return true;
 }
 
 void CreatePrintDialogForBytesImpl(scoped_refptr<base::RefCountedBytes> data,
                                    const string16& print_job_title,
                                    const string16& print_ticket,
                                    const std::string& file_type,
                                    bool modal) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 54 matching lines @@
   }
   if (!pref_service->FindPreference(prefs::kCloudPrintDialogHeight)) {
     pref_service->RegisterIntegerPref(prefs::kCloudPrintDialogHeight,
                                       kDefaultHeight,
                                       PrefService::UNSYNCABLE_PREF);
   }
 
   int width = pref_service->GetInteger(prefs::kCloudPrintDialogWidth);
   int height = pref_service->GetInteger(prefs::kCloudPrintDialogHeight);
 
-  HtmlDialogUIDelegate* dialog_delegate =
-      new internal_cloud_print_helpers::CloudPrintHtmlDialogDelegate(
+  WebDialogDelegate* dialog_delegate =
+      new internal_cloud_print_helpers::CloudPrintWebDialogDelegate(
           path_to_file, width, height, std::string(), job_title, print_ticket,
           file_type, modal, delete_on_close, close_after_signin,
           callback);
-  browser::ShowHtmlDialog(modal ? browser->window()->GetNativeHandle() : NULL,
-                          profile,
-                          browser,
-                          dialog_delegate,
-                          STYLE_GENERIC);
+  browser::ShowWebDialog(modal ? browser->window()->GetNativeHandle() : NULL,
+                         profile,
+                         browser,
+                         dialog_delegate,
+                         STYLE_GENERIC);
 }
 
 void CreateDialogSigninImpl(const base::Closure& callback) {
   CreateDialogImpl(FilePath(), string16(), string16(), std::string(),
                    true, false, true, callback);
 }
 
 void CreateDialogFullImpl(const FilePath& path_to_file,
                       const string16& print_job_title,
                       const string16& print_ticket,
@@ skipping 96 matching lines @@
                                                    file_type,
                                                    false,
                                                    delete_on_close);
       return true;
     }
   }
   return false;
 }
 
 }  // end namespace