Split UserMetrics into API vs. implementation. Move API to content/public.

chrome/browser/ui/pdf/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/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_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/chrome_interstitial_page.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"
 #include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/render_view_host.h"
-#include "content/browser/user_metrics.h"
+#include "content/public/browser/user_metrics.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 
+using content::UserMetricsAction;
 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";
@@ skipping 22 matching lines @@
 
   Profile* profile_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PDFEnableAdobeReaderInfoBarDelegate);
 };
 
 PDFEnableAdobeReaderInfoBarDelegate::PDFEnableAdobeReaderInfoBarDelegate(
     InfoBarTabHelper* infobar_helper, Profile* profile)
     : ConfirmInfoBarDelegate(infobar_helper),
       profile_(profile) {
-  UserMetrics::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarShown"));
+  content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarShown"));
 }
 
 PDFEnableAdobeReaderInfoBarDelegate::~PDFEnableAdobeReaderInfoBarDelegate() {
 }
 
 void PDFEnableAdobeReaderInfoBarDelegate::InfoBarDismissed() {
   OnNo();
 }
 
 InfoBarDelegate::Type
@@ skipping 18 matching lines @@
   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"));
+  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() {
-  UserMetrics::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
+  content::RecordAction(UserMetricsAction("PDF_EnableReaderInfoBarCancel"));
 }
 
 // Launch the url to get the latest Adbobe Reader installer.
 void OpenReaderUpdateURL(TabContents* tab) {
   tab->OpenURL(GURL(kReaderUpdateUrl), GURL(), NEW_FOREGROUND_TAB,
                content::PAGE_TRANSITION_LINK);
 }
 
 // Opens the PDF using Adobe Reader.
 void OpenUsingReader(TabContentsWrapper* tab,
@@ skipping 20 matching lines @@
 // Reader, but it is out of date.
 class PDFUnsupportedFeatureInterstitial : public ChromeInterstitialPage {
  public:
   PDFUnsupportedFeatureInterstitial(
       TabContentsWrapper* tab,
       const WebPluginInfo& reader_webplugininfo)
       : ChromeInterstitialPage(
             tab->tab_contents(), false, tab->tab_contents()->GetURL()),
         tab_contents_(tab),
         reader_webplugininfo_(reader_webplugininfo) {
-    UserMetrics::RecordAction(UserMetricsAction("PDF_ReaderInterstitialShown"));
+    content::RecordAction(UserMetricsAction("PDF_ReaderInterstitialShown"));
   }
 
  protected:
   // ChromeInterstitialPage implementation.
   virtual std::string GetHTMLContents() {
     DictionaryValue strings;
     strings.SetString(
         "title",
         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_TITLE));
     strings.SetString(
@@ skipping 14 matching lines @@
         l10n_util::GetStringUTF16(IDS_READER_OUT_OF_DATE_BLOCKING_PAGE_CANCEL));
 
     base::StringPiece html(ResourceBundle::GetSharedInstance().
         GetRawDataResource(IDR_READER_OUT_OF_DATE_HTML));
 
     return jstemplate_builder::GetI18nTemplateHtml(html, &strings);
   }
 
   virtual void CommandReceived(const std::string& command) {
     if (command == "0") {
-      UserMetrics::RecordAction(
+      content::RecordAction(
           UserMetricsAction("PDF_ReaderInterstitialCancel"));
       DontProceed();
       return;
     }
 
     if (command == "1") {
-      UserMetrics::RecordAction(
+      content::RecordAction(
           UserMetricsAction("PDF_ReaderInterstitialUpdate"));
       OpenReaderUpdateURL(tab());
     } else if (command == "2") {
-      UserMetrics::RecordAction(
+      content::RecordAction(
           UserMetricsAction("PDF_ReaderInterstitialIgnore"));
       OpenUsingReader(tab_contents_, reader_webplugininfo_, NULL, NULL);
     } else {
       NOTREACHED();
     }
     Proceed();
   }
 
  private:
   TabContentsWrapper* tab_contents_;
@@ skipping 34 matching lines @@
 };
 
 PDFUnsupportedFeatureInfoBarDelegate::PDFUnsupportedFeatureInfoBarDelegate(
     TabContentsWrapper* tab_contents,
     const PluginGroup* reader_group)
     : ConfirmInfoBarDelegate(tab_contents->infobar_tab_helper()),
       tab_contents_(tab_contents),
       reader_installed_(!!reader_group),
       reader_vulnerable_(false) {
   if (!reader_installed_) {
-    UserMetrics::RecordAction(
+    content::RecordAction(
         UserMetricsAction("PDF_InstallReaderInfoBarShown"));
     return;
   }
 
-  UserMetrics::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarShown"));
+  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_vulnerable_ = reader_group->IsVulnerable(reader_webplugininfo_);
   if (!reader_vulnerable_) {
     scoped_ptr<Version> version(PluginGroup::CreateVersionFromString(
         reader_webplugininfo_.version));
     reader_vulnerable_ =
@@ skipping 35 matching lines @@
 }
 
 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"));
+    content::RecordAction(UserMetricsAction("PDF_InstallReaderInfoBarOK"));
     OpenReaderUpdateURL(tab_contents_->tab_contents());
     return true;
   }
 
-  UserMetrics::RecordAction(UserMetricsAction("PDF_UseReaderInfoBarOK"));
+  content::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_->infobar_tab_helper(), tab_contents_->profile());
     OpenUsingReader(tab_contents_, reader_webplugininfo_, this, bar);
     return false;
   }
 
   OpenUsingReader(tab_contents_, reader_webplugininfo_, NULL, NULL);
   return true;
 }
 
 void PDFUnsupportedFeatureInfoBarDelegate::OnNo() {
-  UserMetrics::RecordAction(reader_installed_ ?
-      UserMetricsAction("PDF_UseReaderInfoBarCancel") :
+  content::RecordAction(reader_installed_ ?
+                        UserMetricsAction("PDF_UseReaderInfoBarCancel") :
       UserMetricsAction("PDF_InstallReaderInfoBarCancel"));
 }
 
 void GotPluginGroupsCallback(int process_id,
                              int routing_id,
                              const std::vector<PluginGroup>& groups) {
   TabContents* tab_contents =
       tab_util::GetTabContentsByID(process_id, routing_id);
   if (!tab_contents)
     return;
@@ skipping 31 matching lines @@
   // 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->render_view_host()->process()->GetID(),
           tab->render_view_host()->routing_id()));
 }