Reland 156033 - Add an icon and bubble to the location bar to open PDFs in Reader.

chrome/browser/ui/pdf/pdf_unsupported_feature.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/ui/pdf/pdf_unsupported_feature.h"
 
 #include "base/bind.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
-#include "chrome/browser/api/infobars/confirm_infobar_delegate.h"
 #include "chrome/browser/chrome_plugin_service_filter.h"
-#include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/plugin_finder.h"
 #include "chrome/browser/plugin_installer.h"
 #include "chrome/browser/plugin_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/pdf/open_pdf_in_reader_prompt_delegate.h"
 #include "chrome/browser/ui/pdf/pdf_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/interstitial_page_delegate.h"
+#include "content/public/browser/navigation_details.h"
+#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/page_transition_types.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 #endif
 
 using content::InterstitialPage;
 using content::OpenURLParams;
 using content::PluginService;
 using content::Referrer;
 using content::UserMetricsAction;
 using content::WebContents;
 using webkit::npapi::PluginGroup;
 using webkit::WebPluginInfo;
 
 namespace {
 
 static const char kAdobeReaderIdentifier[] = "adobe-reader";
 static const char kAdobeReaderUpdateUrl[] =
     "http://www.adobe.com/go/getreader_chrome";
 
-// The info bar delegate used to ask the user if they want to use Adobe Reader
-// by default.  We want the infobar to have [No][Yes], so we swap the text on
-// the buttons, and the meaning of the delegate callbacks.
-class PDFEnableAdobeReaderInfoBarDelegate : public ConfirmInfoBarDelegate {
+// The prompt delegate used to ask the user if they want to use Adobe Reader
+// by default.
+class PDFEnableAdobeReaderPromptDelegate
+    : public OpenPDFInReaderPromptDelegate {
  public:
-  explicit PDFEnableAdobeReaderInfoBarDelegate(
-      InfoBarTabHelper* infobar_helper,
-      Profile* profile);
-  virtual ~PDFEnableAdobeReaderInfoBarDelegate();
+  explicit PDFEnableAdobeReaderPromptDelegate(Profile* profile);
+  virtual ~PDFEnableAdobeReaderPromptDelegate();
 
-  // ConfirmInfoBarDelegate
-  virtual void InfoBarDismissed() OVERRIDE;
-  virtual Type GetInfoBarType() const OVERRIDE;
-  virtual bool Accept() OVERRIDE;
-  virtual bool Cancel() OVERRIDE;
-  virtual string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;
+  // OpenPDFInReaderPromptDelegate
   virtual string16 GetMessageText() const OVERRIDE;
+  virtual string16 GetAcceptButtonText() const OVERRIDE;
+  virtual string16 GetCancelButtonText() const OVERRIDE;
+  virtual bool ShouldExpire(
+      const content::LoadCommittedDetails& details) const OVERRIDE;
+  virtual void Accept() OVERRIDE;
+  virtual void Cancel() OVERRIDE;
 
  private:
   void OnYes();
   void OnNo();
 
   Profile* profile_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderInfoBarDelegate);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderPromptDelegate);
 };
 
-PDFEnableAdobeReaderInfoBarDelegate::PDFEnableAdobeReaderInfoBarDelegate(
-    InfoBarTabHelper* infobar_helper, Profile* profile)
-    : ConfirmInfoBarDelegate(infobar_helper),
-      profile_(profile) {
+PDFEnableAdobeReaderPromptDelegate::PDFEnableAdobeReaderPromptDelegate(
+    Profile* profile)
+    : profile_(profile) {
   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarShown"));
 }
 
-PDFEnableAdobeReaderInfoBarDelegate::~PDFEnableAdobeReaderInfoBarDelegate() {
+PDFEnableAdobeReaderPromptDelegate::~PDFEnableAdobeReaderPromptDelegate() {
 }
 
-void PDFEnableAdobeReaderInfoBarDelegate::InfoBarDismissed() {
-  OnNo();
+bool PDFEnableAdobeReaderPromptDelegate::ShouldExpire(
+    const content::LoadCommittedDetails& details) const {
+  content::PageTransition transition =
+      content::PageTransitionStripQualifier(details.entry->GetTransitionType());
+  // We don't want to expire on a reload, because that is how we open the PDF in
+  // Reader.
+  return !details.is_in_page && transition != content::PAGE_TRANSITION_RELOAD;
 }
 
-InfoBarDelegate::Type
-    PDFEnableAdobeReaderInfoBarDelegate::GetInfoBarType() const {
-  return PAGE_ACTION_TYPE;
-}
-
-bool PDFEnableAdobeReaderInfoBarDelegate::Accept() {
-  profile_->GetPrefs()->SetBoolean(
-      prefs::kPluginsShowSetReaderDefaultInfobar, false);
-  OnNo();
-  return true;
-}
-
-bool PDFEnableAdobeReaderInfoBarDelegate::Cancel() {
-  OnYes();
-  return true;
-}
-
-string16 PDFEnableAdobeReaderInfoBarDelegate::GetButtonLabel(
-    InfoBarButton button) const {
-  return l10n_util::GetStringUTF16((button == BUTTON_OK) ?
-      IDS_PDF_INFOBAR_NEVER_USE_READER_BUTTON :
-      IDS_PDF_INFOBAR_ALWAYS_USE_READER_BUTTON);
-}
-
-string16 PDFEnableAdobeReaderInfoBarDelegate::GetMessageText() const {
-  return l10n_util::GetStringUTF16(IDS_PDF_INFOBAR_QUESTION_ALWAYS_USE_READER);
-}
-
-void PDFEnableAdobeReaderInfoBarDelegate::OnYes() {
+void PDFEnableAdobeReaderPromptDelegate::Accept() {
   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarOK"));
   PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile_);
   plugin_prefs->EnablePluginGroup(
       true, ASCIIToUTF16(webkit::npapi::PluginGroup::kAdobeReaderGroupName));
   plugin_prefs->EnablePluginGroup(
       false, ASCIIToUTF16(chrome::ChromeContentClient::kPDFPluginName));
 }
 
-void PDFEnableAdobeReaderInfoBarDelegate::OnNo() {
+void PDFEnableAdobeReaderPromptDelegate::Cancel() {
+  // profile_->GetPrefs()->SetBoolean(
+  //     prefs::kPluginsShowSetReaderDefaultInfobar, false);
   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
 }
 
+string16 PDFEnableAdobeReaderPromptDelegate::GetAcceptButtonText() const {
+  return l10n_util::GetStringUTF16(IDS_PDF_INFOBAR_ALWAYS_USE_READER_BUTTON);
+}
+
+string16 PDFEnableAdobeReaderPromptDelegate::GetCancelButtonText() const {
+  return l10n_util::GetStringUTF16(IDS_DONE);
+}
+
+string16 PDFEnableAdobeReaderPromptDelegate::GetMessageText() const {
+  return l10n_util::GetStringUTF16(IDS_PDF_INFOBAR_QUESTION_ALWAYS_USE_READER);
+}
+
 // Launch the url to get the latest Adbobe Reader installer.
 void OpenReaderUpdateURL(WebContents* tab) {
   OpenURLParams params(
       GURL(kAdobeReaderUpdateUrl), Referrer(), NEW_FOREGROUND_TAB,
       content::PAGE_TRANSITION_LINK, false);
   tab->OpenURL(params);
 }
 
 // Opens the PDF using Adobe Reader.
 void OpenUsingReader(WebContents* web_contents,
                      const WebPluginInfo& reader_plugin,
-                     InfoBarDelegate* delegate) {
+                     OpenPDFInReaderPromptDelegate* delegate) {
   ChromePluginServiceFilter::GetInstance()->OverridePluginForTab(
       web_contents->GetRenderProcessHost()->GetID(),
       web_contents->GetRenderViewHost()->GetRoutingID(),
       web_contents->GetURL(),
       reader_plugin);
   web_contents->GetRenderViewHost()->ReloadFrame();
 
+  PDFTabHelper* pdf_tab_helper = PDFTabHelper::FromWebContents(web_contents);
   if (delegate)
-    tab->infobar_tab_helper()->AddInfoBar(delegate);
+    pdf_tab_helper->ShowOpenInReaderPrompt(make_scoped_ptr(delegate));
 }
 
 // An interstitial to be used when the user chooses to open a PDF using Adobe
 // Reader, but it is out of date.
 class PDFUnsupportedFeatureInterstitial
     : public content::InterstitialPageDelegate {
  public:
   PDFUnsupportedFeatureInterstitial(
       TabContents* tab,
       const WebPluginInfo& reader_webplugininfo)
@@ skipping 83 matching lines @@
   // |reader| is NULL if Adobe Reader isn't installed.
   PDFUnsupportedFeaturePromptDelegate(TabContents* tab_contents,
                                       const webkit::WebPluginInfo* reader,
                                       PluginFinder* plugin_finder);
   virtual ~PDFUnsupportedFeaturePromptDelegate();
 
   // OpenPDFInReaderPromptDelegate:
   virtual string16 GetMessageText() const OVERRIDE;
   virtual string16 GetAcceptButtonText() const OVERRIDE;
   virtual string16 GetCancelButtonText() const OVERRIDE;
+  virtual bool ShouldExpire(
+      const content::LoadCommittedDetails& details) const OVERRIDE;
   virtual void Accept() OVERRIDE;
   virtual void Cancel() OVERRIDE;
 
  private:
   TabContents* tab_contents_;
   bool reader_installed_;
   bool reader_vulnerable_;
   WebPluginInfo reader_webplugininfo_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeaturePromptDelegate);
@@ skipping 43 matching lines @@
   if (reader_installed_)
     return l10n_util::GetStringUTF16(IDS_PDF_BUBBLE_OPEN_IN_READER_LINK);
 
   return l10n_util::GetStringUTF16(IDS_PDF_BUBBLE_INSTALL_READER_LINK);
 }
 
 string16 PDFUnsupportedFeaturePromptDelegate::GetCancelButtonText() const {
   return l10n_util::GetStringUTF16(IDS_DONE);
 }
 
+bool PDFUnsupportedFeaturePromptDelegate::ShouldExpire(
+    const content::LoadCommittedDetails& details) const {
+  return !details.is_in_page;
+}
+
 void PDFUnsupportedFeaturePromptDelegate::Accept() {
 #if defined(OS_WIN)
   if (base::win::IsMetroProcess()) {
     browser::AttemptRestartWithModeSwitch();
     return;
   }
 #endif
 
   if (!reader_installed_) {
     content::RecordAction(UserMetricsAction("PDF_InstallReaderInfoBarOK"));
     OpenReaderUpdateURL(tab_contents_->web_contents());
     return;
   }
 
   content::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarOK"));
 
   if (reader_vulnerable_) {
     new PDFUnsupportedFeatureInterstitial(tab_contents_, reader_webplugininfo_);
     return;
   }
 
+  OpenPDFInReaderPromptDelegate* delegate = NULL;
   if (tab_contents_->profile()->GetPrefs()->GetBoolean(
       prefs::kPluginsShowSetReaderDefaultInfobar)) {
-    InfoBarDelegate* bar = new PDFEnableAdobeReaderInfoBarDelegate(
-        tab_contents_->infobar_tab_helper(), tab_contents_->profile());
-    OpenUsingReader(tab_contents_, reader_webplugininfo_, bar);
-    return;
+    delegate =
+        new PDFEnableAdobeReaderPromptDelegate(tab_contents_->profile());
   }
 
-  OpenUsingReader(tab_contents_, reader_webplugininfo_, NULL);
+  OpenUsingReader(tab_contents_->web_contents(), reader_webplugininfo_,
+                  delegate);
 }
 
 void PDFUnsupportedFeaturePromptDelegate::Cancel() {
   content::RecordAction(reader_installed_ ?
                         UserMetricsAction("PDF_UseReaderInfoBarCancel") :
                         UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
 }
 
 void GotPluginsCallback(int process_id,
                         int routing_id,
@@ skipping 43 matching lines @@
 
 void PDFHasUnsupportedFeature(content::WebContents* web_contents) {
 #if defined(OS_WIN) && defined(ENABLE_PLUGIN_INSTALLATION)
   // Only works for Windows for now.  For Mac, we'll have to launch the file
   // externally since Adobe Reader doesn't work inside Chrome.
   PluginFinder::Get(base::Bind(&GotPluginFinderCallback,
       web_contents->GetRenderProcessHost()->GetID(),
       web_contents->GetRenderViewHost()->GetRoutingID()));
 #endif
 }