Remove unneeded TabContents::FromWebContents.

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/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_plugin_service_filter.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/plugins/plugin_finder.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/browser/plugins/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"
@@ skipping 88 matching lines @@
 
 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) {
+void OpenReaderUpdateURL(WebContents* web_contents) {
   OpenURLParams params(
       GURL(kAdobeReaderUpdateUrl), Referrer(), NEW_FOREGROUND_TAB,
       content::PAGE_TRANSITION_LINK, false);
-  tab->OpenURL(params);
+  web_contents->OpenURL(params);
 }
 
 // Opens the PDF using Adobe Reader.
 void OpenUsingReader(WebContents* web_contents,
                      const WebPluginInfo& reader_plugin,
                      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)
     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,
+      WebContents* web_contents,
       const WebPluginInfo& reader_webplugininfo)
-      : tab_contents_(tab),
+      : web_contents_(web_contents),
         reader_webplugininfo_(reader_webplugininfo) {
     content::RecordAction(UserMetricsAction("PDF_ReaderInterstitialShown"));
     interstitial_page_ = InterstitialPage::Create(
-        tab->web_contents(), false, tab->web_contents()->GetURL(), this);
+        web_contents, false, web_contents->GetURL(), this);
     interstitial_page_->Show();
   }
 
  protected:
   // InterstitialPageDelegate implementation.
   virtual std::string GetHTMLContents() OVERRIDE {
     DictionaryValue strings;
     strings.SetString(
         "title",
         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_TITLE));
@@ skipping 24 matching lines @@
     if (command == "0") {
       content::RecordAction(
           UserMetricsAction("PDF_ReaderInterstitialCancel"));
       interstitial_page_->DontProceed();
       return;
     }
 
     if (command == "1") {
       content::RecordAction(
           UserMetricsAction("PDF_ReaderInterstitialUpdate"));
-      OpenReaderUpdateURL(tab_contents_->web_contents());
+      OpenReaderUpdateURL(web_contents_);
     } else if (command == "2") {
       content::RecordAction(
           UserMetricsAction("PDF_ReaderInterstitialIgnore"));
       // Pretend that the plug-in is up-to-date so that we don't block it.
       reader_webplugininfo_.version = ASCIIToUTF16("11.0.0.0");
-      OpenUsingReader(tab_contents_->web_contents(), reader_webplugininfo_,
-                      NULL);
+      OpenUsingReader(web_contents_, reader_webplugininfo_, NULL);
     } else {
       NOTREACHED();
     }
     interstitial_page_->Proceed();
   }
 
   virtual void OverrideRendererPrefs(
       content::RendererPreferences* prefs) OVERRIDE {
-    renderer_preferences_util::UpdateFromSystemSettings(
-        prefs, tab_contents_->profile());
+    Profile* profile =
+        Profile::FromBrowserContext(web_contents_->GetBrowserContext());
+    renderer_preferences_util::UpdateFromSystemSettings(prefs, profile);
   }
 
  private:
-  TabContents* tab_contents_;
+  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 {
  public:
   // |reader| is NULL if Adobe Reader isn't installed.
-  PDFUnsupportedFeaturePromptDelegate(TabContents* tab_contents,
+  PDFUnsupportedFeaturePromptDelegate(WebContents* web_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_;
+  WebContents* web_contents_;
   bool reader_installed_;
   bool reader_vulnerable_;
   WebPluginInfo reader_webplugininfo_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeaturePromptDelegate);
 };
 
 PDFUnsupportedFeaturePromptDelegate::PDFUnsupportedFeaturePromptDelegate(
-    TabContents* tab_contents,
+    WebContents* web_contents,
     const webkit::WebPluginInfo* reader,
     PluginFinder* plugin_finder)
-    : tab_contents_(tab_contents),
+    : web_contents_(web_contents),
       reader_installed_(!!reader),
       reader_vulnerable_(false) {
   if (!reader_installed_) {
     content::RecordAction(
         UserMetricsAction("PDF_InstallReaderInfoBarShown"));
     return;
   }
 
   content::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarShown"));
   reader_webplugininfo_ = *reader;
@@ skipping 40 matching lines @@
 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());
+    OpenReaderUpdateURL(web_contents_);
     return;
   }
 
   content::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarOK"));
 
   if (reader_vulnerable_) {
-    new PDFUnsupportedFeatureInterstitial(tab_contents_, reader_webplugininfo_);
+    new PDFUnsupportedFeatureInterstitial(web_contents_, reader_webplugininfo_);
     return;
   }
 
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   OpenPDFInReaderPromptDelegate* delegate =
-      new PDFEnableAdobeReaderPromptDelegate(tab_contents_->profile());
+      new PDFEnableAdobeReaderPromptDelegate(profile);
 
-  OpenUsingReader(tab_contents_->web_contents(), reader_webplugininfo_,
-                  delegate);
+  OpenUsingReader(web_contents_, reader_webplugininfo_, delegate);
 }
 
 void PDFUnsupportedFeaturePromptDelegate::Cancel() {
   content::RecordAction(reader_installed_ ?
                         UserMetricsAction("PDF_UseReaderInfoBarCancel") :
                         UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
 }
 
 #if defined(OS_WIN) && defined(ENABLE_PLUGIN_INSTALLATION)
 void GotPluginsCallback(int process_id,
                         int routing_id,
                         const std::vector<webkit::WebPluginInfo>& plugins) {
   WebContents* web_contents =
       tab_util::GetWebContentsByID(process_id, routing_id);
   if (!web_contents)
     return;
 
-  TabContents* tab = TabContents::FromWebContents(web_contents);
-  if (!tab)
-    return;
-
   const webkit::WebPluginInfo* reader = NULL;
   PluginFinder* plugin_finder = PluginFinder::GetInstance();
   for (size_t i = 0; i < plugins.size(); ++i) {
     scoped_ptr<PluginMetadata> plugin_metadata(
         plugin_finder->GetPluginMetadata(plugins[i]));
     if (plugin_metadata->identifier() != kAdobeReaderIdentifier)
       continue;
 
     DCHECK(!reader);
     reader = &plugins[i];
     // If the Reader plugin is disabled by policy, don't prompt them.
-    PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(tab->profile());
+    Profile* profile =
+        Profile::FromBrowserContext(web_contents->GetBrowserContext());
+    PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile);
     if (plugin_prefs->PolicyStatusForPlugin(plugin_metadata->name()) ==
         PluginPrefs::POLICY_DISABLED) {
       return;
     }
     break;
   }
 
   scoped_ptr<OpenPDFInReaderPromptDelegate> prompt(
-      new PDFUnsupportedFeaturePromptDelegate(tab, reader, plugin_finder));
+      new PDFUnsupportedFeaturePromptDelegate(
+          web_contents, reader, plugin_finder));
   PDFTabHelper* pdf_tab_helper = PDFTabHelper::FromWebContents(web_contents);
   pdf_tab_helper->ShowOpenInReaderPrompt(prompt.Pass());
 }
 #endif  // defined(OS_WIN) && defined(ENABLE_PLUGIN_INSTALLATION)
 
 }  // namespace
 
 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.
   PluginService::GetInstance()->GetPlugins(base::Bind(&GotPluginsCallback,
       web_contents->GetRenderProcessHost()->GetID(),
       web_contents->GetRenderViewHost()->GetRoutingID()));
 #endif
 }