Replace the virtual InfoBarDelegate::InfoBarClosed() function with a non-virtual one. This is a ...

chrome/browser/pdf_unsupported_feature.cc

 // Copyright (c) 2011 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/pdf_unsupported_feature.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 24 matching lines @@
 
 // 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 PDFEnableAdobeReaderConfirmInfoBarDelegate
-    : public ConfirmInfoBarDelegate {
+class PDFEnableAdobeReaderInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
-  PDFEnableAdobeReaderConfirmInfoBarDelegate(
-      TabContents* tab_contents)
-      : ConfirmInfoBarDelegate(tab_contents),
-        tab_contents_(tab_contents) {
-    UserMetrics::RecordAction(
-        UserMetricsAction("PDF_EnableReaderInfoBarShown"));
-  }
+  explicit PDFEnableAdobeReaderInfoBarDelegate(TabContents* tab_contents);
+  virtual ~PDFEnableAdobeReaderInfoBarDelegate();
 
   // ConfirmInfoBarDelegate
-  virtual void InfoBarClosed() {
-    delete this;
-  }
-
-  virtual void InfoBarDismissed() {
-    OnNo();
-  }
-
-  virtual Type GetInfoBarType() const {
-    return PAGE_ACTION_TYPE;
-  }
-
-  virtual bool Accept() {
-    tab_contents_->profile()->GetPrefs()->SetBoolean(
-        prefs::kPluginsShowSetReaderDefaultInfobar, false);
-    return OnNo();
-  }
-
-  virtual bool Cancel() {
-    return OnYes();
-  }
-
-  virtual int GetButtons() const {
-    return BUTTON_OK | BUTTON_CANCEL;
-  }
-
-  virtual string16 GetButtonLabel(InfoBarButton button) const {
-    switch (button) {
-      case BUTTON_OK:
-        return l10n_util::GetStringUTF16(
-            IDS_PDF_INFOBAR_NEVER_USE_READER_BUTTON);
-      case BUTTON_CANCEL:
-        return l10n_util::GetStringUTF16(
-            IDS_PDF_INFOBAR_ALWAYS_USE_READER_BUTTON);
-      default:
-        // All buttons are labeled above.
-        NOTREACHED() << "Bad button id " << button;
-        return string16();
-    }
-  }
-
-  virtual string16 GetMessageText() const {
-    return l10n_util::GetStringUTF16(
-        IDS_PDF_INFOBAR_QUESTION_ALWAYS_USE_READER);
-  }
+  virtual void InfoBarDismissed() 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() {
-    UserMetrics::RecordAction(
-        UserMetricsAction("PDF_EnableReaderInfoBarOK"));
-    webkit::npapi::PluginList::Singleton()->EnableGroup(
-        false, ASCIIToUTF16(chrome::ChromeContentClient::kPDFPluginName));
-    webkit::npapi::PluginList::Singleton()->EnableGroup(
-        true, ASCIIToUTF16(webkit::npapi::PluginGroup::kAdobeReaderGroupName));
-    return true;
-  }
-
-  bool OnNo() {
-    UserMetrics::RecordAction(
-        UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
-    return true;
-  }
+  void OnYes();
+  void OnNo();
 
   TabContents* tab_contents_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderConfirmInfoBarDelegate);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderInfoBarDelegate);
 };
 
+PDFEnableAdobeReaderInfoBarDelegate::PDFEnableAdobeReaderInfoBarDelegate(
+    TabContents* tab_contents)
+    : ConfirmInfoBarDelegate(tab_contents),
+      tab_contents_(tab_contents) {
+  UserMetrics::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarShown"));
+}
+
+PDFEnableAdobeReaderInfoBarDelegate::~PDFEnableAdobeReaderInfoBarDelegate() {
+}
+
+void PDFEnableAdobeReaderInfoBarDelegate::InfoBarDismissed() {
+  OnNo();
+}
+
+InfoBarDelegate::Type
+    PDFEnableAdobeReaderInfoBarDelegate::GetInfoBarType() const {
+  return PAGE_ACTION_TYPE;
+}
+
+bool PDFEnableAdobeReaderInfoBarDelegate::Accept() {
+  tab_contents_->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() {
+  UserMetrics::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarOK"));
+  webkit::npapi::PluginList::Singleton()->EnableGroup(false,
+      ASCIIToUTF16(chrome::ChromeContentClient::kPDFPluginName));
+  webkit::npapi::PluginList::Singleton()->EnableGroup(true,
+      ASCIIToUTF16(webkit::npapi::PluginGroup::kAdobeReaderGroupName));
+}
+
+void PDFEnableAdobeReaderInfoBarDelegate::OnNo() {
+  UserMetrics::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
+}
+
 // Launch the url to get the latest Adbobe Reader installer.
 void OpenReaderUpdateURL(TabContents* tab) {
   tab->OpenURL(GURL(kReaderUpdateUrl), GURL(), CURRENT_TAB,
                PageTransition::LINK);
 }
 
 // Opens the PDF using Adobe Reader.
 void OpenUsingReader(TabContents* tab,
                      const WebPluginInfo& reader_plugin,
                      InfoBarDelegate* old_delegate,
@@ skipping 87 matching lines @@
   }
 
  private:
   WebPluginInfo reader_webplugininfo_;
 
   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
-// PDFEnableAdobeReaderConfirmInfoBarDelegate.
-class PDFUnsupportedFeatureConfirmInfoBarDelegate
-    : public ConfirmInfoBarDelegate {
+// PDFEnableAdobeReaderInfoBarDelegate.
+class PDFUnsupportedFeatureInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
-  PDFUnsupportedFeatureConfirmInfoBarDelegate(
-      TabContents* tab_contents,
-      PluginGroup* reader_group)  // NULL if Adobe Reader isn't installed.
-      : ConfirmInfoBarDelegate(tab_contents),
-        tab_contents_(tab_contents),
-        reader_installed_(!!reader_group),
-        reader_vulnerable_(false) {
-    if (reader_installed_) {
-      UserMetrics::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarShown"));
-      std::vector<WebPluginInfo> plugins = reader_group->web_plugin_infos();
-      DCHECK_EQ(plugins.size(), 1u);
-      reader_webplugininfo_ = plugins[0];
-
-      reader_vulnerable_ = reader_group->IsVulnerable();
-      if (!reader_vulnerable_) {
-        scoped_ptr<Version> version(PluginGroup::CreateVersionFromString(
-            reader_webplugininfo_.version));
-        if (version.get()) {
-          if (version->components()[0] < kMinReaderVersionToUse)
-            reader_vulnerable_ = true;
-        }
-      }
-    } else {
-      UserMetrics::RecordAction(
-          UserMetricsAction("PDF_InstallReaderInfoBarShown"));
-    }
-  }
+  // |reader_group| is NULL if Adobe Reader isn't installed.
+  PDFUnsupportedFeatureInfoBarDelegate(TabContents* tab_contents,
+                                       PluginGroup* reader_group);
+  virtual ~PDFUnsupportedFeatureInfoBarDelegate();
 
   // ConfirmInfoBarDelegate
-  virtual void InfoBarClosed() {
-    delete this;
-  }
-
-  virtual void InfoBarDismissed() {
-    OnNo();
-  }
-
-  virtual Type GetInfoBarType() const {
-    return PAGE_ACTION_TYPE;
-  }
-
-  virtual bool Accept() {
-    return OnNo();
-  }
-
-  virtual bool Cancel() {
-    return OnYes();
-  }
-
-  virtual int GetButtons() const {
-    return BUTTON_OK | BUTTON_CANCEL;
-  }
-
-  virtual string16 GetButtonLabel(InfoBarButton button) const {
-    switch (button) {
-      case BUTTON_OK:
-        return l10n_util::GetStringUTF16(
-            IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL);
-      case BUTTON_CANCEL:
-        return l10n_util::GetStringUTF16(
-            IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL);
-      default:
-        // All buttons are labeled above.
-        NOTREACHED() << "Bad button id " << button;
-        return string16();
-    }
-  }
-
-  virtual string16 GetMessageText() const {
-    return l10n_util::GetStringUTF16(reader_installed_ ?
-        IDS_PDF_INFOBAR_QUESTION_READER_INSTALLED :
-        IDS_PDF_INFOBAR_QUESTION_READER_NOT_INSTALLED);
-  }
+  virtual void InfoBarDismissed() 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() {
-   if (!reader_installed_) {
-      UserMetrics::RecordAction(
-          UserMetricsAction("PDF_InstallReaderInfoBarOK"));
-      OpenReaderUpdateURL(tab_contents_);
-      return true;
-    }
-
-    UserMetrics::RecordAction(
-        UserMetricsAction("PDF_UseReaderInfoBarOK"));
-
-    if (reader_vulnerable_) {
-      PDFUnsupportedFeatureInterstitial* interstitial = new
-          PDFUnsupportedFeatureInterstitial(
-              tab_contents_, reader_webplugininfo_);
-      interstitial->Show();
-      return true;
-    }
-
-    InfoBarDelegate* bar = NULL;
-    if (tab_contents_->profile()->GetPrefs()->GetBoolean(
-            prefs::kPluginsShowSetReaderDefaultInfobar)) {
-      bar = new PDFEnableAdobeReaderConfirmInfoBarDelegate(tab_contents_);
-    }
-
-    if (bar) {
-      OpenUsingReader(tab_contents_, reader_webplugininfo_, this, bar);
-      return false;
-    } else {
-      OpenUsingReader(tab_contents_, reader_webplugininfo_, NULL, NULL);
-      return true;
-    }
-  }
-
-  bool OnNo() {
-    if (reader_installed_) {
-      UserMetrics::RecordAction(
-          UserMetricsAction("PDF_UseReaderInfoBarCancel"));
-    } else {
-      UserMetrics::RecordAction(
-          UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
-    }
-    return true;
-  }
+  bool OnYes();
+  void OnNo();
 
   TabContents* tab_contents_;
   bool reader_installed_;
   bool reader_vulnerable_;
   WebPluginInfo reader_webplugininfo_;
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeatureConfirmInfoBarDelegate);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PDFUnsupportedFeatureInfoBarDelegate);
 };
 
+PDFUnsupportedFeatureInfoBarDelegate::PDFUnsupportedFeatureInfoBarDelegate(
+    TabContents* tab_contents,
+    PluginGroup* reader_group)
+    : ConfirmInfoBarDelegate(tab_contents),
+      tab_contents_(tab_contents),
+      reader_installed_(!!reader_group),
+      reader_vulnerable_(false) {
+  if (!reader_installed_) {
+    UserMetrics::RecordAction(
+        UserMetricsAction("PDF_InstallReaderInfoBarShown"));
+    return;
+  }
+
+  UserMetrics::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarShown"));
+  std::vector<WebPluginInfo> plugins = reader_group->web_plugin_infos();
+  DCHECK_EQ(plugins.size(), 1u);
+  reader_webplugininfo_ = plugins[0];
+
+  reader_vulnerable_ = reader_group->IsVulnerable();
+  if (!reader_vulnerable_) {
+    scoped_ptr<Version> version(PluginGroup::CreateVersionFromString(
+        reader_webplugininfo_.version));
+    reader_vulnerable_ =
+        version.get() && (version->components()[0] < kMinReaderVersionToUse);
+  }
+}
+
+PDFUnsupportedFeatureInfoBarDelegate::~PDFUnsupportedFeatureInfoBarDelegate() {
+}
+
+void PDFUnsupportedFeatureInfoBarDelegate::InfoBarDismissed() {
+  OnNo();
+}
+
+InfoBarDelegate::Type
+    PDFUnsupportedFeatureInfoBarDelegate::GetInfoBarType() const {
+  return PAGE_ACTION_TYPE;
+}
+
+bool PDFUnsupportedFeatureInfoBarDelegate::Accept() {
+  OnNo();
+  return true;
+}
+
+bool PDFUnsupportedFeatureInfoBarDelegate::Cancel() {
+  return OnYes();
+}
+
+string16 PDFUnsupportedFeatureInfoBarDelegate::GetButtonLabel(
+    InfoBarButton button) const {
+  return l10n_util::GetStringUTF16((button == BUTTON_OK) ?
+      IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL :
+      IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL);
+}
+
+string16 PDFUnsupportedFeatureInfoBarDelegate::GetMessageText() const {
+  return l10n_util::GetStringUTF16(reader_installed_ ?
+      IDS_PDF_INFOBAR_QUESTION_READER_INSTALLED :
+      IDS_PDF_INFOBAR_QUESTION_READER_NOT_INSTALLED);
+}
+
+bool PDFUnsupportedFeatureInfoBarDelegate::OnYes() {
+  if (!reader_installed_) {
+    UserMetrics::RecordAction(UserMetricsAction("PDF_InstallReaderInfoBarOK"));
+    OpenReaderUpdateURL(tab_contents_);
+    return true;
+  }
+
+  UserMetrics::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarOK"));
+
+  if (reader_vulnerable_) {
+    PDFUnsupportedFeatureInterstitial* interstitial =
+        new PDFUnsupportedFeatureInterstitial(tab_contents_,
+                                              reader_webplugininfo_);
+    interstitial->Show();
+    return true;
+  }
+
+  if (tab_contents_->profile()->GetPrefs()->GetBoolean(
+      prefs::kPluginsShowSetReaderDefaultInfobar)) {
+    InfoBarDelegate* bar =
+        new PDFEnableAdobeReaderInfoBarDelegate(tab_contents_);
+    OpenUsingReader(tab_contents_, reader_webplugininfo_, this, bar);
+    return false;
+  }
+
+  OpenUsingReader(tab_contents_, reader_webplugininfo_, NULL, NULL);
+  return true;
+}
+
+void PDFUnsupportedFeatureInfoBarDelegate::OnNo() {
+  UserMetrics::RecordAction(UserMetricsAction(reader_installed_ ?
+      "PDF_UseReaderInfoBarCancel" : "PDF_InstallReaderInfoBarCancel"));
+}
+
 }  // namespace
 
 void PDFHasUnsupportedFeature(TabContents* 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
   string16 reader_group_name(ASCIIToUTF16(PluginGroup::kAdobeReaderGroupName));
 
   // If the Reader plugin is disabled by policy, don't prompt them.
   if (PluginGroup::IsPluginNameDisabledByPolicy(reader_group_name))
     return;
 
   PluginGroup* reader_group = NULL;
   std::vector<PluginGroup> plugin_groups;
   PluginList::Singleton()->GetPluginGroups(
       false, &plugin_groups);
   for (size_t i = 0; i < plugin_groups.size(); ++i) {
     if (plugin_groups[i].GetGroupName() == reader_group_name) {
       reader_group = &plugin_groups[i];
       break;
     }
   }
 
-  tab->AddInfoBar(new PDFUnsupportedFeatureConfirmInfoBarDelegate(
-      tab, reader_group));
+  tab->AddInfoBar(new PDFUnsupportedFeatureInfoBarDelegate(tab, reader_group));
 }