Move version metadata from PluginGroup into PluginInstaller.

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/chrome_plugin_service_filter.h"
 #include "chrome/browser/infobars/infobar_tab_helper.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/confirm_infobar_delegate.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
@@ skipping 16 matching lines @@
 using content::OpenURLParams;
 using content::PluginService;
 using content::Referrer;
 using content::UserMetricsAction;
 using content::WebContents;
 using webkit::npapi::PluginGroup;
 using webkit::WebPluginInfo;
 
 namespace {
 
-// Only launch Adobe Reader X or later.
-static const uint16 kMinReaderVersionToUse = 10;
-
 static const char kReaderUpdateUrl[] =
     "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 {
  public:
   explicit PDFEnableAdobeReaderInfoBarDelegate(
       InfoBarTabHelper* infobar_helper,
@@ skipping 181 matching lines @@
   InterstitialPage* interstitial_page_;  // Owns us.
 
   DISALLOW_COPY_AND_ASSIGN(PDFUnsupportedFeatureInterstitial);
 };
 
 // The info bar delegate used to inform the user that we don't support a feature
 // in the PDF.  See the comment about how we swap buttons for
 // PDFEnableAdobeReaderInfoBarDelegate.
 class PDFUnsupportedFeatureInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
-  // |reader_group| is NULL if Adobe Reader isn't installed.
+  // |reader| is NULL if Adobe Reader isn't installed.
   PDFUnsupportedFeatureInfoBarDelegate(TabContentsWrapper* tab_contents,
-                                       const PluginGroup* reader_group);
+                                       const webkit::WebPluginInfo* reader,
+                                       PluginFinder* plugin_finder);
   virtual ~PDFUnsupportedFeatureInfoBarDelegate();
 
   // ConfirmInfoBarDelegate
   virtual void InfoBarDismissed() OVERRIDE;
   virtual gfx::Image* GetIcon() const OVERRIDE;
   virtual Type GetInfoBarType() const OVERRIDE;
   virtual bool Accept() OVERRIDE;
   virtual bool Cancel() OVERRIDE;
   virtual string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;
   virtual string16 GetMessageText() const OVERRIDE;
 
  private:
   bool OnYes();
   void OnNo();
 
   TabContentsWrapper* tab_contents_;
   bool reader_installed_;
   bool reader_vulnerable_;
   WebPluginInfo reader_webplugininfo_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeatureInfoBarDelegate);
 };
 
 PDFUnsupportedFeatureInfoBarDelegate::PDFUnsupportedFeatureInfoBarDelegate(
     TabContentsWrapper* tab_contents,
-    const PluginGroup* reader_group)
+    const webkit::WebPluginInfo* reader,
+    PluginFinder* plugin_finder)
     : ConfirmInfoBarDelegate(tab_contents->infobar_tab_helper()),
       tab_contents_(tab_contents),
-      reader_installed_(!!reader_group),
+      reader_installed_(!!reader),
       reader_vulnerable_(false) {
   if (!reader_installed_) {
     content::RecordAction(
         UserMetricsAction("PDF_InstallReaderInfoBarShown"));
     return;
   }
 
   content::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarShown"));
-  const std::vector<WebPluginInfo>& plugins =
-      reader_group->web_plugin_infos();
-  DCHECK_EQ(plugins.size(), 1u);
-  reader_webplugininfo_ = plugins[0];
+  reader_webplugininfo_ = *reader;
 
-  reader_vulnerable_ = reader_group->IsVulnerable(reader_webplugininfo_);
-  if (!reader_vulnerable_) {
-    scoped_ptr<Version> version(PluginGroup::CreateVersionFromString(
-        reader_webplugininfo_.version));
-    reader_vulnerable_ =
-        version.get() && (version->components()[0] < kMinReaderVersionToUse);
-  }
+  PluginInstaller* installer =
+      plugin_finder->FindPluginWithIdentifier("adobe-reader");
+
+  reader_vulnerable_ =
+      installer->GetSecurityStatus(*reader) !=
+          PluginInstaller::SECURITY_STATUS_UP_TO_DATE;
 }
 
 PDFUnsupportedFeatureInfoBarDelegate::~PDFUnsupportedFeatureInfoBarDelegate() {
 }
 
 void PDFUnsupportedFeatureInfoBarDelegate::InfoBarDismissed() {
   OnNo();
 }
 
 gfx::Image* PDFUnsupportedFeatureInfoBarDelegate::GetIcon() const {
@@ skipping 55 matching lines @@
 }
 
 void PDFUnsupportedFeatureInfoBarDelegate::OnNo() {
   content::RecordAction(reader_installed_ ?
                         UserMetricsAction("PDF_UseReaderInfoBarCancel") :
                         UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
 }
 
 void GotPluginGroupsCallback(int process_id,
                              int routing_id,
+                             PluginFinder* plugin_finder,
                              const std::vector<PluginGroup>& groups) {
   WebContents* web_contents =
       tab_util::GetWebContentsByID(process_id, routing_id);
   if (!web_contents)
     return;
 
   TabContentsWrapper* tab =
       TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
   if (!tab)
     return;
 
   string16 reader_group_name(ASCIIToUTF16(PluginGroup::kAdobeReaderGroupName));
-
   // If the Reader plugin is disabled by policy, don't prompt them.
   PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(tab->profile());
   if (plugin_prefs->PolicyStatusForPlugin(reader_group_name) ==
       PluginPrefs::POLICY_DISABLED) {
     return;
   }
 
-  const PluginGroup* reader_group = NULL;
+  const webkit::WebPluginInfo* reader = NULL;
   for (size_t i = 0; i < groups.size(); ++i) {
     if (groups[i].GetGroupName() == reader_group_name) {
-      reader_group = &groups[i];
+      const std::vector<WebPluginInfo>& plugins =
+          groups[i].web_plugin_infos();
+      DCHECK_EQ(plugins.size(), 1u);
+      reader = &plugins[0];
       break;
     }
   }
 
   tab->infobar_tab_helper()->AddInfoBar(
-      new PDFUnsupportedFeatureInfoBarDelegate(tab, reader_group));
+      new PDFUnsupportedFeatureInfoBarDelegate(tab, reader, plugin_finder));
+}
+
+void GotPluginFinderCallback(int process_id,
+                             int routing_id,
+                             PluginFinder* plugin_finder) {
+  PluginService::GetInstance()->GetPluginGroups(
+      base::Bind(&GotPluginGroupsCallback, process_id, routing_id,
+                                           base::Unretained(plugin_finder)));
 }
 
 }  // namespace
 
 void PDFHasUnsupportedFeature(TabContentsWrapper* tab) {
 #if !defined(OS_WIN)
   // Only works for Windows for now.  For Mac, we'll have to launch the file
   // externally since Adobe Reader doesn't work inside Chrome.
   return;
 #endif
 
-  PluginService::GetInstance()->GetPluginGroups(
-      base::Bind(&GotPluginGroupsCallback,
-          tab->web_contents()->GetRenderProcessHost()->GetID(),
-          tab->web_contents()->GetRenderViewHost()->GetRoutingID()));
+  PluginFinder::Get(base::Bind(&GotPluginFinderCallback,
+      tab->web_contents()->GetRenderProcessHost()->GetID(),
+      tab->web_contents()->GetRenderViewHost()->GetRoutingID()));
 }