pdf: Create a separate component for using the pdf pepper plugin.

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/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/browser/plugins/plugin_prefs.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/common/chrome_content_client.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/pdf/browser/open_pdf_in_reader_prompt_client.h"
+#include "components/pdf/browser/pdf_web_contents_helper.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/page_navigator.h"
 #include "content/public/browser/render_frame_host.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"
@@ skipping 14 matching lines @@
 using content::WebContents;
 using content::WebPluginInfo;
 
 #if defined(OS_WIN)
 namespace {
 
 const char kAdobeReaderUpdateUrl[] = "http://www.adobe.com/go/getreader_chrome";
 
 // The prompt delegate used to ask the user if they want to use Adobe Reader
 // by default.
-class PDFEnableAdobeReaderPromptDelegate
-    : public OpenPDFInReaderPromptDelegate {
+class PDFEnableAdobeReaderPromptClient
+    : public pdf::OpenPDFInReaderPromptClient {
  public:
-  explicit PDFEnableAdobeReaderPromptDelegate(Profile* profile);
-  virtual ~PDFEnableAdobeReaderPromptDelegate();
+  explicit PDFEnableAdobeReaderPromptClient(Profile* profile);
+  virtual ~PDFEnableAdobeReaderPromptClient();
 
-  // OpenPDFInReaderPromptDelegate
+  // pdf::OpenPDFInReaderPromptClient
   virtual base::string16 GetMessageText() const OVERRIDE;
   virtual base::string16 GetAcceptButtonText() const OVERRIDE;
   virtual base::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(PDFEnableAdobeReaderPromptDelegate);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderPromptClient);
 };
 
-PDFEnableAdobeReaderPromptDelegate::PDFEnableAdobeReaderPromptDelegate(
+PDFEnableAdobeReaderPromptClient::PDFEnableAdobeReaderPromptClient(
     Profile* profile)
     : profile_(profile) {
   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarShown"));
 }
 
-PDFEnableAdobeReaderPromptDelegate::~PDFEnableAdobeReaderPromptDelegate() {
+PDFEnableAdobeReaderPromptClient::~PDFEnableAdobeReaderPromptClient() {
 }
 
-bool PDFEnableAdobeReaderPromptDelegate::ShouldExpire(
+bool PDFEnableAdobeReaderPromptClient::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;
 }
 
-void PDFEnableAdobeReaderPromptDelegate::Accept() {
+void PDFEnableAdobeReaderPromptClient::Accept() {
   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarOK"));
   PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile_).get();
   plugin_prefs->EnablePluginGroup(
       true, base::ASCIIToUTF16(PluginMetadata::kAdobeReaderGroupName));
   plugin_prefs->EnablePluginGroup(
       false, base::ASCIIToUTF16(ChromeContentClient::kPDFPluginName));
 }
 
-void PDFEnableAdobeReaderPromptDelegate::Cancel() {
+void PDFEnableAdobeReaderPromptClient::Cancel() {
   content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
 }
 
-base::string16 PDFEnableAdobeReaderPromptDelegate::GetAcceptButtonText() const {
+base::string16 PDFEnableAdobeReaderPromptClient::GetAcceptButtonText() const {
   return l10n_util::GetStringUTF16(IDS_PDF_INFOBAR_ALWAYS_USE_READER_BUTTON);
 }
 
-base::string16 PDFEnableAdobeReaderPromptDelegate::GetCancelButtonText() const {
+base::string16 PDFEnableAdobeReaderPromptClient::GetCancelButtonText() const {
   return l10n_util::GetStringUTF16(IDS_DONE);
 }
 
-base::string16 PDFEnableAdobeReaderPromptDelegate::GetMessageText() const {
+base::string16 PDFEnableAdobeReaderPromptClient::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* web_contents) {
   OpenURLParams params(
       GURL(kAdobeReaderUpdateUrl), Referrer(), NEW_FOREGROUND_TAB,
       content::PAGE_TRANSITION_LINK, false);
   web_contents->OpenURL(params);
 }
 
 // Opens the PDF using Adobe Reader.
 void OpenUsingReader(WebContents* web_contents,
                      const WebPluginInfo& reader_plugin,
-                     OpenPDFInReaderPromptDelegate* delegate) {
+                     pdf::OpenPDFInReaderPromptClient* client) {
   ChromePluginServiceFilter::GetInstance()->OverridePluginForFrame(
       web_contents->GetRenderProcessHost()->GetID(),
       web_contents->GetMainFrame()->GetRoutingID(),
       web_contents->GetURL(),
       reader_plugin);
   web_contents->ReloadFocusedFrame(false);
 
-  PDFTabHelper* pdf_tab_helper = PDFTabHelper::FromWebContents(web_contents);
-  if (delegate)
-    pdf_tab_helper->ShowOpenInReaderPrompt(make_scoped_ptr(delegate));
+  pdf::PDFWebContentsHelper* pdf_tab_helper =
+      pdf::PDFWebContentsHelper::FromWebContents(web_contents);
+  if (client)
+    pdf_tab_helper->ShowOpenInReaderPrompt(make_scoped_ptr(client));
 }
 
 // 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(
       WebContents* web_contents,
       const WebPluginInfo& reader_webplugininfo)
@@ skipping 69 matching lines @@
  private:
   WebContents* web_contents_;
   WebPluginInfo reader_webplugininfo_;
   InterstitialPage* interstitial_page_;  // Owns us.
 
   DISALLOW_COPY_AND_ASSIGN(PDFUnsupportedFeatureInterstitial);
 };
 
 // The delegate for the bubble used to inform the user that we don't support a
 // feature in the PDF.
-class PDFUnsupportedFeaturePromptDelegate
-    : public OpenPDFInReaderPromptDelegate {
+class PDFUnsupportedFeaturePromptClient
+    : public pdf::OpenPDFInReaderPromptClient {
  public:
-  PDFUnsupportedFeaturePromptDelegate(
-      WebContents* web_contents,
-      const AdobeReaderPluginInfo& reader_info);
-  virtual ~PDFUnsupportedFeaturePromptDelegate();
+  PDFUnsupportedFeaturePromptClient(WebContents* web_contents,
+                                    const AdobeReaderPluginInfo& reader_info);
+  virtual ~PDFUnsupportedFeaturePromptClient();
 
-  // OpenPDFInReaderPromptDelegate:
+  // pdf::OpenPDFInReaderPromptClient:
   virtual base::string16 GetMessageText() const OVERRIDE;
   virtual base::string16 GetAcceptButtonText() const OVERRIDE;
   virtual base::string16 GetCancelButtonText() const OVERRIDE;
   virtual bool ShouldExpire(
       const content::LoadCommittedDetails& details) const OVERRIDE;
   virtual void Accept() OVERRIDE;
   virtual void Cancel() OVERRIDE;
 
  private:
   WebContents* web_contents_;
   const AdobeReaderPluginInfo reader_info_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeaturePromptDelegate);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeaturePromptClient);
 };
 
-PDFUnsupportedFeaturePromptDelegate::PDFUnsupportedFeaturePromptDelegate(
+PDFUnsupportedFeaturePromptClient::PDFUnsupportedFeaturePromptClient(
     WebContents* web_contents,
     const AdobeReaderPluginInfo& reader_info)
-    : web_contents_(web_contents),
-      reader_info_(reader_info) {
+    : web_contents_(web_contents), reader_info_(reader_info) {
   content::RecordAction(reader_info_.is_installed ?
                         UserMetricsAction("PDF_UseReaderInfoBarShown") :
                         UserMetricsAction("PDF_InstallReaderInfoBarShown"));
 }
 
-PDFUnsupportedFeaturePromptDelegate::~PDFUnsupportedFeaturePromptDelegate() {
+PDFUnsupportedFeaturePromptClient::~PDFUnsupportedFeaturePromptClient() {
 }
 
-base::string16 PDFUnsupportedFeaturePromptDelegate::GetMessageText() const {
+base::string16 PDFUnsupportedFeaturePromptClient::GetMessageText() const {
   return l10n_util::GetStringUTF16(IDS_PDF_BUBBLE_MESSAGE);
 }
 
-base::string16 PDFUnsupportedFeaturePromptDelegate::GetAcceptButtonText()
-    const {
+base::string16 PDFUnsupportedFeaturePromptClient::GetAcceptButtonText() const {
   if (base::win::IsMetroProcess())
     return l10n_util::GetStringUTF16(IDS_PDF_BUBBLE_METRO_MODE_LINK);
 
   return l10n_util::GetStringUTF16(
       reader_info_.is_installed ? IDS_PDF_BUBBLE_OPEN_IN_READER_LINK
                                 : IDS_PDF_BUBBLE_INSTALL_READER_LINK);
 }
 
-base::string16 PDFUnsupportedFeaturePromptDelegate::GetCancelButtonText()
-    const {
+base::string16 PDFUnsupportedFeaturePromptClient::GetCancelButtonText() const {
   return l10n_util::GetStringUTF16(IDS_DONE);
 }
 
-bool PDFUnsupportedFeaturePromptDelegate::ShouldExpire(
+bool PDFUnsupportedFeaturePromptClient::ShouldExpire(
     const content::LoadCommittedDetails& details) const {
   return !details.is_in_page;
 }
 
-void PDFUnsupportedFeaturePromptDelegate::Accept() {
+void PDFUnsupportedFeaturePromptClient::Accept() {
   if (base::win::IsMetroProcess()) {
     chrome::AttemptRestartWithModeSwitch();
     return;
   }
 
   if (!reader_info_.is_installed) {
     content::RecordAction(UserMetricsAction("PDF_InstallReaderInfoBarOK"));
     OpenReaderUpdateURL(web_contents_);
     return;
   }
 
   content::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarOK"));
 
   if (!reader_info_.is_secure) {
     new PDFUnsupportedFeatureInterstitial(web_contents_,
                                           reader_info_.plugin_info);
     return;
   }
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
-  OpenPDFInReaderPromptDelegate* delegate =
-      new PDFEnableAdobeReaderPromptDelegate(profile);
+  pdf::OpenPDFInReaderPromptClient* client =
+      new PDFEnableAdobeReaderPromptClient(profile);
 
-  OpenUsingReader(web_contents_, reader_info_.plugin_info, delegate);
+  OpenUsingReader(web_contents_, reader_info_.plugin_info, client);
 }
 
-void PDFUnsupportedFeaturePromptDelegate::Cancel() {
+void PDFUnsupportedFeaturePromptClient::Cancel() {
   content::RecordAction(reader_info_.is_installed ?
                         UserMetricsAction("PDF_UseReaderInfoBarCancel") :
                         UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
 }
 
 void MaybeShowOpenPDFInReaderPrompt(WebContents* web_contents,
                                     const AdobeReaderPluginInfo& reader_info) {
   // If the Reader plugin is disabled by policy, don't prompt them.
   if (!reader_info.is_installed || !reader_info.is_enabled)
     return;
 
-  scoped_ptr<OpenPDFInReaderPromptDelegate> prompt(
-      new PDFUnsupportedFeaturePromptDelegate(web_contents, reader_info));
-  PDFTabHelper* pdf_tab_helper = PDFTabHelper::FromWebContents(web_contents);
+  scoped_ptr<pdf::OpenPDFInReaderPromptClient> prompt(
+      new PDFUnsupportedFeaturePromptClient(web_contents, reader_info));
+  pdf::PDFWebContentsHelper* pdf_tab_helper =
+      pdf::PDFWebContentsHelper::FromWebContents(web_contents);
   pdf_tab_helper->ShowOpenInReaderPrompt(prompt.Pass());
 }
 
 void GotPluginsCallback(int process_id,
                         int routing_id,
                         const AdobeReaderPluginInfo& reader_info) {
   WebContents* web_contents =
       tab_util::GetWebContentsByID(process_id, routing_id);
   if (web_contents)
     MaybeShowOpenPDFInReaderPrompt(web_contents, reader_info);
@@ skipping 13 matching lines @@
     MaybeShowOpenPDFInReaderPrompt(web_contents, reader_info);
     return;
   }
   GetAdobeReaderPluginInfoAsync(
       profile,
       base::Bind(&GotPluginsCallback,
                  web_contents->GetRenderProcessHost()->GetID(),
                  web_contents->GetRenderViewHost()->GetRoutingID()));
 #endif  // defined(OS_WIN)
 }