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_preview_dialog_controller.h"
      6 
      7 #include <algorithm>
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/auto_reset.h"
     12 #include "base/path_service.h"
     13 #include "base/strings/utf_string_conversions.h"
     14 #include "chrome/browser/browser_process.h"
     15 #include "chrome/browser/chrome_notification_types.h"
     16 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
     17 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
     18 #include "chrome/browser/printing/print_view_manager.h"
     19 #include "chrome/browser/profiles/profile.h"
     20 #include "chrome/browser/ui/browser.h"
     21 #include "chrome/browser/ui/browser_finder.h"
     22 #include "chrome/browser/ui/browser_navigator.h"
     23 #include "chrome/browser/ui/browser_window.h"
     24 #include "chrome/browser/ui/host_desktop.h"
     25 #include "chrome/browser/ui/webui/chrome_web_contents_handler.h"
     26 #include "chrome/browser/ui/webui/constrained_web_dialog_ui.h"
     27 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
     28 #include "chrome/common/chrome_content_client.h"
     29 #include "chrome/common/chrome_paths.h"
     30 #include "chrome/common/url_constants.h"
     31 #include "components/web_modal/web_contents_modal_dialog_host.h"
     32 #include "content/public/browser/navigation_controller.h"
     33 #include "content/public/browser/navigation_details.h"
     34 #include "content/public/browser/navigation_entry.h"
     35 #include "content/public/browser/notification_details.h"
     36 #include "content/public/browser/notification_source.h"
     37 #include "content/public/browser/plugin_service.h"
     38 #include "content/public/browser/render_frame_host.h"
     39 #include "content/public/browser/render_process_host.h"
     40 #include "content/public/browser/render_view_host.h"
     41 #include "content/public/browser/web_contents.h"
     42 #include "content/public/browser/web_contents_delegate.h"
     43 #include "content/public/common/webplugininfo.h"
     44 #include "ui/web_dialogs/web_dialog_delegate.h"
     45 #include "ui/web_dialogs/web_dialog_web_contents_delegate.h"
     46 
     47 using content::NativeWebKeyboardEvent;
     48 using content::NavigationController;
     49 using content::WebContents;
     50 using content::WebUIMessageHandler;
     51 using ui::WebDialogDelegate;
     52 using ui::WebDialogWebContentsDelegate;
     53 
     54 namespace {
     55 
     56 void EnableInternalPDFPluginForContents(WebContents* preview_dialog) {
     57   // Always enable the internal PDF plugin for the print preview page.
     58   base::FilePath pdf_plugin_path;
     59   if (!PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_plugin_path))
     60     return;
     61 
     62   content::WebPluginInfo pdf_plugin;
     63   if (!content::PluginService::GetInstance()->GetPluginInfoByPath(
     64       pdf_plugin_path, &pdf_plugin))
     65     return;
     66 
     67   ChromePluginServiceFilter::GetInstance()->OverridePluginForFrame(
     68       preview_dialog->GetRenderProcessHost()->GetID(),
     69       preview_dialog->GetMainFrame()->GetRoutingID(),
     70       GURL(), pdf_plugin);
     71 }
     72 
     73 // WebDialogDelegate that specifies what the print preview dialog
     74 // will look like.
     75 class PrintPreviewDialogDelegate : public WebDialogDelegate {
     76  public:
     77   explicit PrintPreviewDialogDelegate(WebContents* initiator);
     78   virtual ~PrintPreviewDialogDelegate();
     79 
     80   virtual ui::ModalType GetDialogModalType() const OVERRIDE;
     81   virtual base::string16 GetDialogTitle() const OVERRIDE;
     82   virtual GURL GetDialogContentURL() const OVERRIDE;
     83   virtual void GetWebUIMessageHandlers(
     84       std::vector<WebUIMessageHandler*>* handlers) const OVERRIDE;
     85   virtual void GetDialogSize(gfx::Size* size) const OVERRIDE;
     86   virtual std::string GetDialogArgs() const OVERRIDE;
     87   virtual void OnDialogClosed(const std::string& json_retval) OVERRIDE;
     88   virtual void OnCloseContents(WebContents* source,
     89                                bool* out_close_dialog) OVERRIDE;
     90   virtual bool ShouldShowDialogTitle() const OVERRIDE;
     91 
     92  private:
     93   WebContents* initiator_;
     94 
     95   DISALLOW_COPY_AND_ASSIGN(PrintPreviewDialogDelegate);
     96 };
     97 
     98 PrintPreviewDialogDelegate::PrintPreviewDialogDelegate(WebContents* initiator)
     99     : initiator_(initiator) {
    100 }
    101 
    102 PrintPreviewDialogDelegate::~PrintPreviewDialogDelegate() {
    103 }
    104 
    105 ui::ModalType PrintPreviewDialogDelegate::GetDialogModalType() const {
    106   // Not used, returning dummy value.
    107   NOTREACHED();
    108   return ui::MODAL_TYPE_WINDOW;
    109 }
    110 
    111 base::string16 PrintPreviewDialogDelegate::GetDialogTitle() const {
    112   // Only used on Windows? UI folks prefer no title.
    113   return base::string16();
    114 }
    115 
    116 GURL PrintPreviewDialogDelegate::GetDialogContentURL() const {
    117   return GURL(chrome::kChromeUIPrintURL);
    118 }
    119 
    120 void PrintPreviewDialogDelegate::GetWebUIMessageHandlers(
    121     std::vector<WebUIMessageHandler*>* /* handlers */) const {
    122   // PrintPreviewUI adds its own message handlers.
    123 }
    124 
    125 void PrintPreviewDialogDelegate::GetDialogSize(gfx::Size* size) const {
    126   DCHECK(size);
    127   const gfx::Size kMinDialogSize(800, 480);
    128   const int kBorder = 25;
    129   *size = kMinDialogSize;
    130 
    131   web_modal::WebContentsModalDialogHost* host = NULL;
    132   Browser* browser = chrome::FindBrowserWithWebContents(initiator_);
    133   if (browser)
    134     host = browser->window()->GetWebContentsModalDialogHost();
    135 
    136   if (host) {
    137     size->SetToMax(host->GetMaximumDialogSize());
    138     size->Enlarge(-2 * kBorder, -kBorder);
    139   } else {
    140     size->SetToMax(initiator_->GetContainerBounds().size());
    141     size->Enlarge(-2 * kBorder, -2 * kBorder);
    142   }
    143 
    144 #if defined(OS_MACOSX)
    145   // Limit the maximum size on MacOS X.
    146   // http://crbug.com/105815
    147   const gfx::Size kMaxDialogSize(1000, 660);
    148   size->SetToMin(kMaxDialogSize);
    149 #endif
    150 }
    151 
    152 std::string PrintPreviewDialogDelegate::GetDialogArgs() const {
    153   return std::string();
    154 }
    155 
    156 void PrintPreviewDialogDelegate::OnDialogClosed(
    157     const std::string& /* json_retval */) {
    158 }
    159 
    160 void PrintPreviewDialogDelegate::OnCloseContents(WebContents* /* source */,
    161                                                  bool* out_close_dialog) {
    162   if (out_close_dialog)
    163     *out_close_dialog = true;
    164 }
    165 
    166 bool PrintPreviewDialogDelegate::ShouldShowDialogTitle() const {
    167   return false;
    168 }
    169 
    170 // WebContentsDelegate that forwards shortcut keys in the print preview
    171 // renderer to the browser.
    172 class PrintPreviewWebContentDelegate : public WebDialogWebContentsDelegate {
    173  public:
    174   PrintPreviewWebContentDelegate(Profile* profile, WebContents* initiator);
    175   virtual ~PrintPreviewWebContentDelegate();
    176 
    177   // Overridden from WebDialogWebContentsDelegate:
    178   virtual void HandleKeyboardEvent(
    179       WebContents* source,
    180       const NativeWebKeyboardEvent& event) OVERRIDE;
    181 
    182  private:
    183   WebContents* initiator_;
    184 
    185   DISALLOW_COPY_AND_ASSIGN(PrintPreviewWebContentDelegate);
    186 };
    187 
    188 PrintPreviewWebContentDelegate::PrintPreviewWebContentDelegate(
    189     Profile* profile,
    190     WebContents* initiator)
    191     : WebDialogWebContentsDelegate(profile, new ChromeWebContentsHandler),
    192       initiator_(initiator) {}
    193 
    194 PrintPreviewWebContentDelegate::~PrintPreviewWebContentDelegate() {}
    195 
    196 void PrintPreviewWebContentDelegate::HandleKeyboardEvent(
    197     WebContents* source,
    198     const NativeWebKeyboardEvent& event) {
    199   // Disabled on Mac due to http://crbug.com/112173
    200 #if !defined(OS_MACOSX)
    201   Browser* current_browser = chrome::FindBrowserWithWebContents(initiator_);
    202   if (!current_browser)
    203     return;
    204   current_browser->window()->HandleKeyboardEvent(event);
    205 #endif
    206 }
    207 
    208 }  // namespace
    209 
    210 namespace printing {
    211 
    212 PrintPreviewDialogController::PrintPreviewDialogController()
    213     : waiting_for_new_preview_page_(false),
    214       is_creating_print_preview_dialog_(false) {
    215 }
    216 
    217 // static
    218 PrintPreviewDialogController* PrintPreviewDialogController::GetInstance() {
    219   if (!g_browser_process)
    220     return NULL;
    221   return g_browser_process->print_preview_dialog_controller();
    222 }
    223 
    224 // static
    225 void PrintPreviewDialogController::PrintPreview(WebContents* initiator) {
    226   if (initiator->ShowingInterstitialPage())
    227     return;
    228 
    229   PrintPreviewDialogController* dialog_controller = GetInstance();
    230   if (!dialog_controller)
    231     return;
    232   if (!dialog_controller->GetOrCreatePreviewDialog(initiator))
    233     PrintViewManager::FromWebContents(initiator)->PrintPreviewDone();
    234 }
    235 
    236 WebContents* PrintPreviewDialogController::GetOrCreatePreviewDialog(
    237     WebContents* initiator) {
    238   DCHECK(initiator);
    239 
    240   // Get the print preview dialog for |initiator|.
    241   WebContents* preview_dialog = GetPrintPreviewForContents(initiator);
    242   if (!preview_dialog)
    243     return CreatePrintPreviewDialog(initiator);
    244 
    245   // Show the initiator holding the existing preview dialog.
    246   initiator->GetDelegate()->ActivateContents(initiator);
    247   return preview_dialog;
    248 }
    249 
    250 WebContents* PrintPreviewDialogController::GetPrintPreviewForContents(
    251     WebContents* contents) const {
    252   // |preview_dialog_map_| is keyed by the preview dialog, so if find()
    253   // succeeds, then |contents| is the preview dialog.
    254   PrintPreviewDialogMap::const_iterator it = preview_dialog_map_.find(contents);
    255   if (it != preview_dialog_map_.end())
    256     return contents;
    257 
    258   for (it = preview_dialog_map_.begin();
    259        it != preview_dialog_map_.end();
    260        ++it) {
    261     // If |contents| is an initiator.
    262     if (contents == it->second) {
    263       // Return the associated preview dialog.
    264       return it->first;
    265     }
    266   }
    267   return NULL;
    268 }
    269 
    270 WebContents* PrintPreviewDialogController::GetInitiator(
    271     WebContents* preview_dialog) {
    272   PrintPreviewDialogMap::iterator it = preview_dialog_map_.find(preview_dialog);
    273   return (it != preview_dialog_map_.end()) ? it->second : NULL;
    274 }
    275 
    276 void PrintPreviewDialogController::Observe(
    277     int type,
    278     const content::NotificationSource& source,
    279     const content::NotificationDetails& details) {
    280   if (type == content::NOTIFICATION_RENDERER_PROCESS_CLOSED) {
    281     OnRendererProcessClosed(
    282         content::Source<content::RenderProcessHost>(source).ptr());
    283   } else if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
    284     OnWebContentsDestroyed(content::Source<WebContents>(source).ptr());
    285   } else {
    286     DCHECK_EQ(content::NOTIFICATION_NAV_ENTRY_COMMITTED, type);
    287     WebContents* contents =
    288         content::Source<NavigationController>(source)->GetWebContents();
    289     OnNavEntryCommitted(
    290         contents,
    291         content::Details<content::LoadCommittedDetails>(details).ptr());
    292   }
    293 }
    294 
    295 void PrintPreviewDialogController::ForEachPreviewDialog(
    296     base::Callback<void(content::WebContents*)> callback) {
    297   for (PrintPreviewDialogMap::const_iterator it = preview_dialog_map_.begin();
    298        it != preview_dialog_map_.end();
    299        ++it) {
    300     callback.Run(it->first);
    301   }
    302 }
    303 
    304 // static
    305 bool PrintPreviewDialogController::IsPrintPreviewDialog(WebContents* contents) {
    306   return IsPrintPreviewURL(contents->GetURL());
    307 }
    308 
    309 // static
    310 bool PrintPreviewDialogController::IsPrintPreviewURL(const GURL& url) {
    311   return (url.SchemeIs(content::kChromeUIScheme) &&
    312           url.host() == chrome::kChromeUIPrintHost);
    313 }
    314 
    315 void PrintPreviewDialogController::EraseInitiatorInfo(
    316     WebContents* preview_dialog) {
    317   PrintPreviewDialogMap::iterator it = preview_dialog_map_.find(preview_dialog);
    318   if (it == preview_dialog_map_.end())
    319     return;
    320 
    321   RemoveObservers(it->second);
    322   preview_dialog_map_[preview_dialog] = NULL;
    323 }
    324 
    325 PrintPreviewDialogController::~PrintPreviewDialogController() {}
    326 
    327 void PrintPreviewDialogController::OnRendererProcessClosed(
    328     content::RenderProcessHost* rph) {
    329   // Store contents in a vector and deal with them after iterating through
    330   // |preview_dialog_map_| because RemoveFoo() can change |preview_dialog_map_|.
    331   std::vector<WebContents*> closed_initiators;
    332   std::vector<WebContents*> closed_preview_dialogs;
    333   for (PrintPreviewDialogMap::iterator iter = preview_dialog_map_.begin();
    334        iter != preview_dialog_map_.end(); ++iter) {
    335     WebContents* preview_dialog = iter->first;
    336     WebContents* initiator = iter->second;
    337     if (preview_dialog->GetRenderProcessHost() == rph) {
    338       closed_preview_dialogs.push_back(preview_dialog);
    339     } else if (initiator &&
    340                initiator->GetRenderProcessHost() == rph) {
    341       closed_initiators.push_back(initiator);
    342     }
    343   }
    344 
    345   for (size_t i = 0; i < closed_preview_dialogs.size(); ++i) {
    346     RemovePreviewDialog(closed_preview_dialogs[i]);
    347     if (content::WebUI* web_ui = closed_preview_dialogs[i]->GetWebUI()) {
    348       PrintPreviewUI* print_preview_ui =
    349           static_cast<PrintPreviewUI*>(web_ui->GetController());
    350       if (print_preview_ui)
    351         print_preview_ui->OnPrintPreviewDialogClosed();
    352     }
    353   }
    354 
    355   for (size_t i = 0; i < closed_initiators.size(); ++i)
    356     RemoveInitiator(closed_initiators[i]);
    357 }
    358 
    359 void PrintPreviewDialogController::OnWebContentsDestroyed(
    360     WebContents* contents) {
    361   WebContents* preview_dialog = GetPrintPreviewForContents(contents);
    362   if (!preview_dialog) {
    363     NOTREACHED();
    364     return;
    365   }
    366 
    367   if (contents == preview_dialog)
    368     RemovePreviewDialog(contents);
    369   else
    370     RemoveInitiator(contents);
    371 }
    372 
    373 void PrintPreviewDialogController::OnNavEntryCommitted(
    374     WebContents* contents, content::LoadCommittedDetails* details) {
    375   WebContents* preview_dialog = GetPrintPreviewForContents(contents);
    376   if (!preview_dialog) {
    377     NOTREACHED();
    378     return;
    379   }
    380 
    381   if (contents == preview_dialog) {
    382     // Preview dialog navigated.
    383     if (details) {
    384       content::PageTransition transition_type =
    385           details->entry->GetTransitionType();
    386       content::NavigationType nav_type = details->type;
    387 
    388       // New |preview_dialog| is created. Don't update/erase map entry.
    389       if (waiting_for_new_preview_page_ &&
    390           transition_type == content::PAGE_TRANSITION_AUTO_TOPLEVEL &&
    391           nav_type == content::NAVIGATION_TYPE_NEW_PAGE) {
    392         waiting_for_new_preview_page_ = false;
    393         SaveInitiatorTitle(preview_dialog);
    394         return;
    395       }
    396 
    397       // Cloud print sign-in causes a reload.
    398       if (!waiting_for_new_preview_page_ &&
    399           transition_type == content::PAGE_TRANSITION_RELOAD &&
    400           nav_type == content::NAVIGATION_TYPE_EXISTING_PAGE &&
    401           IsPrintPreviewURL(details->previous_url)) {
    402         return;
    403       }
    404     }
    405     NOTREACHED();
    406     return;
    407   }
    408 
    409   RemoveInitiator(contents);
    410 }
    411 
    412 WebContents* PrintPreviewDialogController::CreatePrintPreviewDialog(
    413     WebContents* initiator) {
    414   base::AutoReset<bool> auto_reset(&is_creating_print_preview_dialog_, true);
    415   Profile* profile =
    416       Profile::FromBrowserContext(initiator->GetBrowserContext());
    417 
    418   // |web_dialog_ui_delegate| deletes itself in
    419   // PrintPreviewDialogDelegate::OnDialogClosed().
    420   WebDialogDelegate* web_dialog_delegate =
    421       new PrintPreviewDialogDelegate(initiator);
    422   // |web_dialog_delegate|'s owner is |constrained_delegate|.
    423   PrintPreviewWebContentDelegate* pp_wcd =
    424       new PrintPreviewWebContentDelegate(profile, initiator);
    425   ConstrainedWebDialogDelegate* constrained_delegate =
    426       CreateConstrainedWebDialog(profile,
    427                                  web_dialog_delegate,
    428                                  pp_wcd,
    429                                  initiator);
    430   WebContents* preview_dialog = constrained_delegate->GetWebContents();
    431   EnableInternalPDFPluginForContents(preview_dialog);
    432   PrintViewManager::CreateForWebContents(preview_dialog);
    433   extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
    434       preview_dialog);
    435 
    436   // Add an entry to the map.
    437   preview_dialog_map_[preview_dialog] = initiator;
    438   waiting_for_new_preview_page_ = true;
    439 
    440   AddObservers(initiator);
    441   AddObservers(preview_dialog);
    442 
    443   return preview_dialog;
    444 }
    445 
    446 void PrintPreviewDialogController::SaveInitiatorTitle(
    447     WebContents* preview_dialog) {
    448   WebContents* initiator = GetInitiator(preview_dialog);
    449   if (initiator && preview_dialog->GetWebUI()) {
    450     PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
    451         preview_dialog->GetWebUI()->GetController());
    452     print_preview_ui->SetInitiatorTitle(
    453         PrintViewManager::FromWebContents(initiator)->RenderSourceName());
    454   }
    455 }
    456 
    457 void PrintPreviewDialogController::AddObservers(WebContents* contents) {
    458   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
    459                  content::Source<WebContents>(contents));
    460   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
    461       content::Source<NavigationController>(&contents->GetController()));
    462 
    463   // Multiple sites may share the same RenderProcessHost, so check if this
    464   // notification has already been added.
    465   content::Source<content::RenderProcessHost> rph_source(
    466       contents->GetRenderProcessHost());
    467   if (!registrar_.IsRegistered(this,
    468       content::NOTIFICATION_RENDERER_PROCESS_CLOSED, rph_source)) {
    469     registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
    470                    rph_source);
    471   }
    472 }
    473 
    474 void PrintPreviewDialogController::RemoveObservers(WebContents* contents) {
    475   registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
    476                     content::Source<WebContents>(contents));
    477   registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
    478       content::Source<NavigationController>(&contents->GetController()));
    479 
    480   // Multiple sites may share the same RenderProcessHost, so check if this
    481   // notification has already been added.
    482   content::Source<content::RenderProcessHost> rph_source(
    483       contents->GetRenderProcessHost());
    484   if (registrar_.IsRegistered(this,
    485       content::NOTIFICATION_RENDERER_PROCESS_CLOSED, rph_source)) {
    486     registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
    487                       rph_source);
    488   }
    489 }
    490 
    491 void PrintPreviewDialogController::RemoveInitiator(
    492     WebContents* initiator) {
    493   WebContents* preview_dialog = GetPrintPreviewForContents(initiator);
    494   DCHECK(preview_dialog);
    495   // Update the map entry first, so when the print preview dialog gets destroyed
    496   // and reaches RemovePreviewDialog(), it does not attempt to also remove the
    497   // initiator's observers.
    498   preview_dialog_map_[preview_dialog] = NULL;
    499   RemoveObservers(initiator);
    500 
    501   PrintViewManager::FromWebContents(initiator)->PrintPreviewDone();
    502 
    503   // initiator is closed. Close the print preview dialog too.
    504   if (content::WebUI* web_ui = preview_dialog->GetWebUI()) {
    505     PrintPreviewUI* print_preview_ui =
    506         static_cast<PrintPreviewUI*>(web_ui->GetController());
    507     if (print_preview_ui)
    508       print_preview_ui->OnInitiatorClosed();
    509   }
    510 }
    511 
    512 void PrintPreviewDialogController::RemovePreviewDialog(
    513     WebContents* preview_dialog) {
    514   // Remove the initiator's observers before erasing the mapping.
    515   WebContents* initiator = GetInitiator(preview_dialog);
    516   if (initiator) {
    517     RemoveObservers(initiator);
    518     PrintViewManager::FromWebContents(initiator)->PrintPreviewDone();
    519   }
    520 
    521   // Print preview WebContents is destroyed. Notify |PrintPreviewUI| to abort
    522   // the initiator preview request.
    523   if (content::WebUI* web_ui = preview_dialog->GetWebUI()) {
    524     PrintPreviewUI* print_preview_ui =
    525         static_cast<PrintPreviewUI*>(web_ui->GetController());
    526     if (print_preview_ui)
    527       print_preview_ui->OnPrintPreviewDialogDestroyed();
    528   }
    529 
    530   preview_dialog_map_.erase(preview_dialog);
    531   RemoveObservers(preview_dialog);
    532 }
    533 
    534 }  // namespace printing
    535