chrome/browser/ui/pdf/pdf_unsupported_feature.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/ui/pdf/pdf_unsupported_feature.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/lifetime/application_lifetime.h"
  11 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
  12 #include "chrome/browser/plugins/plugin_metadata.h"
  13 #include "chrome/browser/plugins/plugin_prefs.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/renderer_preferences_util.h"
  16 #include "chrome/browser/tab_contents/tab_util.h"
  17 #include "chrome/browser/ui/pdf/open_pdf_in_reader_prompt_delegate.h"
  18 #include "chrome/browser/ui/pdf/pdf_tab_helper.h"
  19 #include "chrome/common/chrome_content_client.h"
  20 #include "content/public/browser/interstitial_page.h"
  21 #include "content/public/browser/interstitial_page_delegate.h"
  22 #include "content/public/browser/navigation_details.h"
  23 #include "content/public/browser/navigation_entry.h"
  24 #include "content/public/browser/page_navigator.h"
  25 #include "content/public/browser/render_frame_host.h"
  26 #include "content/public/browser/render_process_host.h"
  27 #include "content/public/browser/render_view_host.h"
  28 #include "content/public/browser/user_metrics.h"
  29 #include "content/public/browser/web_contents.h"
  30 #include "grit/browser_resources.h"
  31 #include "grit/generated_resources.h"
  32 #include "ui/base/l10n/l10n_util.h"
  33 #include "ui/base/resource/resource_bundle.h"
  34 #include "ui/base/webui/jstemplate_builder.h"
  35
  36 #if defined(OS_WIN)
  37 #include "base/win/metro.h"
  38 #include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
  39 #endif
  40
  41 using base::UserMetricsAction;
  42 using content::InterstitialPage;
  43 using content::OpenURLParams;
  44 using content::Referrer;
  45 using content::WebContents;
  46 using content::WebPluginInfo;
  47
  48 #if defined(OS_WIN)
  49 namespace {
  50
  51 const char kAdobeReaderUpdateUrl[] = "http://www.adobe.com/go/getreader_chrome";
  52
  53 // The prompt delegate used to ask the user if they want to use Adobe Reader
  54 // by default.
  55 class PDFEnableAdobeReaderPromptDelegate
  56     : public OpenPDFInReaderPromptDelegate {
  57  public:
  58   explicit PDFEnableAdobeReaderPromptDelegate(Profile* profile);
  59   virtual ~PDFEnableAdobeReaderPromptDelegate();
  60
  61   // OpenPDFInReaderPromptDelegate
  62   virtual base::string16 GetMessageText() const OVERRIDE;
  63   virtual base::string16 GetAcceptButtonText() const OVERRIDE;
  64   virtual base::string16 GetCancelButtonText() const OVERRIDE;
  65   virtual bool ShouldExpire(
  66       const content::LoadCommittedDetails& details) const OVERRIDE;
  67   virtual void Accept() OVERRIDE;
  68   virtual void Cancel() OVERRIDE;
  69
  70  private:
  71   void OnYes();
  72   void OnNo();
  73
  74   Profile* profile_;
  75
  76   DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderPromptDelegate);
  77 };
  78
  79 PDFEnableAdobeReaderPromptDelegate::PDFEnableAdobeReaderPromptDelegate(
  80     Profile* profile)
  81     : profile_(profile) {
  82   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarShown"));
  83 }
  84
  85 PDFEnableAdobeReaderPromptDelegate::~PDFEnableAdobeReaderPromptDelegate() {
  86 }
  87
  88 bool PDFEnableAdobeReaderPromptDelegate::ShouldExpire(
  89     const content::LoadCommittedDetails& details) const {
  90   content::PageTransition transition =
  91       content::PageTransitionStripQualifier(details.entry->GetTransitionType());
  92   // We don't want to expire on a reload, because that is how we open the PDF in
  93   // Reader.
  94   return !details.is_in_page && transition != content::PAGE_TRANSITION_RELOAD;
  95 }
  96
  97 void PDFEnableAdobeReaderPromptDelegate::Accept() {
  98   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarOK"));
  99   PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile_).get();
 100   plugin_prefs->EnablePluginGroup(
 101       true, base::ASCIIToUTF16(PluginMetadata::kAdobeReaderGroupName));
 102   plugin_prefs->EnablePluginGroup(
 103       false, base::ASCIIToUTF16(ChromeContentClient::kPDFPluginName));
 104 }
 105
 106 void PDFEnableAdobeReaderPromptDelegate::Cancel() {
 107   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
 108 }
 109
 110 base::string16 PDFEnableAdobeReaderPromptDelegate::GetAcceptButtonText() const {
 111   return l10n_util::GetStringUTF16(IDS_PDF_INFOBAR_ALWAYS_USE_READER_BUTTON);
 112 }
 113
 114 base::string16 PDFEnableAdobeReaderPromptDelegate::GetCancelButtonText() const {
 115   return l10n_util::GetStringUTF16(IDS_DONE);
 116 }
 117
 118 base::string16 PDFEnableAdobeReaderPromptDelegate::GetMessageText() const {
 119   return l10n_util::GetStringUTF16(IDS_PDF_INFOBAR_QUESTION_ALWAYS_USE_READER);
 120 }
 121
 122 // Launch the url to get the latest Adbobe Reader installer.
 123 void OpenReaderUpdateURL(WebContents* web_contents) {
 124   OpenURLParams params(
 125       GURL(kAdobeReaderUpdateUrl), Referrer(), NEW_FOREGROUND_TAB,
 126       content::PAGE_TRANSITION_LINK, false);
 127   web_contents->OpenURL(params);
 128 }
 129
 130 // Opens the PDF using Adobe Reader.
 131 void OpenUsingReader(WebContents* web_contents,
 132                      const WebPluginInfo& reader_plugin,
 133                      OpenPDFInReaderPromptDelegate* delegate) {
 134   ChromePluginServiceFilter::GetInstance()->OverridePluginForFrame(
 135       web_contents->GetRenderProcessHost()->GetID(),
 136       web_contents->GetMainFrame()->GetRoutingID(),
 137       web_contents->GetURL(),
 138       reader_plugin);
 139   web_contents->ReloadFocusedFrame(false);
 140
 141   PDFTabHelper* pdf_tab_helper = PDFTabHelper::FromWebContents(web_contents);
 142   if (delegate)
 143     pdf_tab_helper->ShowOpenInReaderPrompt(make_scoped_ptr(delegate));
 144 }
 145
 146 // An interstitial to be used when the user chooses to open a PDF using Adobe
 147 // Reader, but it is out of date.
 148 class PDFUnsupportedFeatureInterstitial
 149     : public content::InterstitialPageDelegate {
 150  public:
 151   PDFUnsupportedFeatureInterstitial(
 152       WebContents* web_contents,
 153       const WebPluginInfo& reader_webplugininfo)
 154       : web_contents_(web_contents),
 155         reader_webplugininfo_(reader_webplugininfo) {
 156     content::RecordAction(UserMetricsAction("PDF_ReaderInterstitialShown"));
 157     interstitial_page_ = InterstitialPage::Create(
 158         web_contents, false, web_contents->GetURL(), this);
 159     interstitial_page_->Show();
 160   }
 161
 162  protected:
 163   // InterstitialPageDelegate implementation.
 164   virtual std::string GetHTMLContents() OVERRIDE {
 165     base::DictionaryValue strings;
 166     strings.SetString(
 167         "title",
 168         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_TITLE));
 169     strings.SetString(
 170         "headLine",
 171         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_BODY));
 172     strings.SetString(
 173         "update",
 174         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_UPDATE));
 175     strings.SetString(
 176         "open_with_reader",
 177         l10n_util::GetStringUTF16(
 178             IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_PROCEED));
 179     strings.SetString(
 180         "ok",
 181         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_OK));
 182     strings.SetString(
 183         "cancel",
 184         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_CANCEL));
 185
 186     base::StringPiece html(ResourceBundle::GetSharedInstance().
 187                            GetRawDataResource(IDR_READER_OUT_OF_DATE_HTML));
 188
 189     return webui::GetI18nTemplateHtml(html, &strings);
 190   }
 191
 192   virtual void CommandReceived(const std::string& command) OVERRIDE {
 193     if (command == "0") {
 194       content::RecordAction(
 195           UserMetricsAction("PDF_ReaderInterstitialCancel"));
 196       interstitial_page_->DontProceed();
 197       return;
 198     }
 199
 200     if (command == "1") {
 201       content::RecordAction(
 202           UserMetricsAction("PDF_ReaderInterstitialUpdate"));
 203       OpenReaderUpdateURL(web_contents_);
 204     } else if (command == "2") {
 205       content::RecordAction(
 206           UserMetricsAction("PDF_ReaderInterstitialIgnore"));
 207       // Pretend that the plug-in is up-to-date so that we don't block it.
 208       reader_webplugininfo_.version = base::ASCIIToUTF16("11.0.0.0");
 209       OpenUsingReader(web_contents_, reader_webplugininfo_, NULL);
 210     } else {
 211       NOTREACHED();
 212     }
 213     interstitial_page_->Proceed();
 214   }
 215
 216   virtual void OverrideRendererPrefs(
 217       content::RendererPreferences* prefs) OVERRIDE {
 218     Profile* profile =
 219         Profile::FromBrowserContext(web_contents_->GetBrowserContext());
 220     renderer_preferences_util::UpdateFromSystemSettings(prefs, profile);
 221   }
 222
 223  private:
 224   WebContents* web_contents_;
 225   WebPluginInfo reader_webplugininfo_;
 226   InterstitialPage* interstitial_page_;  // Owns us.
 227
 228   DISALLOW_COPY_AND_ASSIGN(PDFUnsupportedFeatureInterstitial);
 229 };
 230
 231 // The delegate for the bubble used to inform the user that we don't support a
 232 // feature in the PDF.
 233 class PDFUnsupportedFeaturePromptDelegate
 234     : public OpenPDFInReaderPromptDelegate {
 235  public:
 236   PDFUnsupportedFeaturePromptDelegate(
 237       WebContents* web_contents,
 238       const AdobeReaderPluginInfo& reader_info);
 239   virtual ~PDFUnsupportedFeaturePromptDelegate();
 240
 241   // OpenPDFInReaderPromptDelegate:
 242   virtual base::string16 GetMessageText() const OVERRIDE;
 243   virtual base::string16 GetAcceptButtonText() const OVERRIDE;
 244   virtual base::string16 GetCancelButtonText() const OVERRIDE;
 245   virtual bool ShouldExpire(
 246       const content::LoadCommittedDetails& details) const OVERRIDE;
 247   virtual void Accept() OVERRIDE;
 248   virtual void Cancel() OVERRIDE;
 249
 250  private:
 251   WebContents* web_contents_;
 252   const AdobeReaderPluginInfo reader_info_;
 253
 254   DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeaturePromptDelegate);
 255 };
 256
 257 PDFUnsupportedFeaturePromptDelegate::PDFUnsupportedFeaturePromptDelegate(
 258     WebContents* web_contents,
 259     const AdobeReaderPluginInfo& reader_info)
 260     : web_contents_(web_contents),
 261       reader_info_(reader_info) {
 262   content::RecordAction(reader_info_.is_installed ?
 263                         UserMetricsAction("PDF_UseReaderInfoBarShown") :
 264                         UserMetricsAction("PDF_InstallReaderInfoBarShown"));
 265 }
 266
 267 PDFUnsupportedFeaturePromptDelegate::~PDFUnsupportedFeaturePromptDelegate() {
 268 }
 269
 270 base::string16 PDFUnsupportedFeaturePromptDelegate::GetMessageText() const {
 271   return l10n_util::GetStringUTF16(IDS_PDF_BUBBLE_MESSAGE);
 272 }
 273
 274 base::string16 PDFUnsupportedFeaturePromptDelegate::GetAcceptButtonText()
 275     const {
 276   if (base::win::IsMetroProcess())
 277     return l10n_util::GetStringUTF16(IDS_PDF_BUBBLE_METRO_MODE_LINK);
 278
 279   return l10n_util::GetStringUTF16(
 280       reader_info_.is_installed ? IDS_PDF_BUBBLE_OPEN_IN_READER_LINK
 281                                 : IDS_PDF_BUBBLE_INSTALL_READER_LINK);
 282 }
 283
 284 base::string16 PDFUnsupportedFeaturePromptDelegate::GetCancelButtonText()
 285     const {
 286   return l10n_util::GetStringUTF16(IDS_DONE);
 287 }
 288
 289 bool PDFUnsupportedFeaturePromptDelegate::ShouldExpire(
 290     const content::LoadCommittedDetails& details) const {
 291   return !details.is_in_page;
 292 }
 293
 294 void PDFUnsupportedFeaturePromptDelegate::Accept() {
 295   if (base::win::IsMetroProcess()) {
 296     chrome::AttemptRestartWithModeSwitch();
 297     return;
 298   }
 299
 300   if (!reader_info_.is_installed) {
 301     content::RecordAction(UserMetricsAction("PDF_InstallReaderInfoBarOK"));
 302     OpenReaderUpdateURL(web_contents_);
 303     return;
 304   }
 305
 306   content::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarOK"));
 307
 308   if (!reader_info_.is_secure) {
 309     new PDFUnsupportedFeatureInterstitial(web_contents_,
 310                                           reader_info_.plugin_info);
 311     return;
 312   }
 313
 314   Profile* profile =
 315       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
 316   OpenPDFInReaderPromptDelegate* delegate =
 317       new PDFEnableAdobeReaderPromptDelegate(profile);
 318
 319   OpenUsingReader(web_contents_, reader_info_.plugin_info, delegate);
 320 }
 321
 322 void PDFUnsupportedFeaturePromptDelegate::Cancel() {
 323   content::RecordAction(reader_info_.is_installed ?
 324                         UserMetricsAction("PDF_UseReaderInfoBarCancel") :
 325                         UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
 326 }
 327
 328 void MaybeShowOpenPDFInReaderPrompt(WebContents* web_contents,
 329                                     const AdobeReaderPluginInfo& reader_info) {
 330   // If the Reader plugin is disabled by policy, don't prompt them.
 331   if (!reader_info.is_installed || !reader_info.is_enabled)
 332     return;
 333
 334   scoped_ptr<OpenPDFInReaderPromptDelegate> prompt(
 335       new PDFUnsupportedFeaturePromptDelegate(web_contents, reader_info));
 336   PDFTabHelper* pdf_tab_helper = PDFTabHelper::FromWebContents(web_contents);
 337   pdf_tab_helper->ShowOpenInReaderPrompt(prompt.Pass());
 338 }
 339
 340 void GotPluginsCallback(int process_id,
 341                         int routing_id,
 342                         const AdobeReaderPluginInfo& reader_info) {
 343   WebContents* web_contents =
 344       tab_util::GetWebContentsByID(process_id, routing_id);
 345   if (web_contents)
 346     MaybeShowOpenPDFInReaderPrompt(web_contents, reader_info);
 347 }
 348
 349 }  // namespace
 350 #endif  // defined(OS_WIN)
 351
 352 void PDFHasUnsupportedFeature(WebContents* web_contents) {
 353 #if defined(OS_WIN)
 354   // Only works for Windows for now.  For Mac, we'll have to launch the file
 355   // externally since Adobe Reader doesn't work inside Chrome.
 356   Profile* profile =
 357       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 358   AdobeReaderPluginInfo reader_info;
 359   if (GetAdobeReaderPluginInfo(profile, &reader_info)) {
 360     MaybeShowOpenPDFInReaderPrompt(web_contents, reader_info);
 361     return;
 362   }
 363   GetAdobeReaderPluginInfoAsync(
 364       profile,
 365       base::Bind(&GotPluginsCallback,
 366                  web_contents->GetRenderProcessHost()->GetID(),
 367                  web_contents->GetRenderViewHost()->GetRoutingID()));
 368 #endif  // defined(OS_WIN)
 369 }