Create PluginMetricsProvider class.

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 156 matching lines @@
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
-#include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked_objects.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 #include "chrome/browser/metrics/compression_utils.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_state_manager.h"
 #include "chrome/browser/metrics/network_metrics_provider.h"
 #include "chrome/browser/metrics/omnibox_metrics_provider.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/variations/variations_util.h"
 #include "components/metrics/metrics_log_base.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_scheduler.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/variations/entropy_provider.h"
-#include "components/variations/metrics_util.h"
 #include "content/public/browser/child_process_data.h"
-#include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/user_metrics.h"
-#include "content/public/common/process_type.h"
-#include "content/public/common/webplugininfo.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 
+#if defined(ENABLE_PLUGINS)
+// TODO(asvitkine): Move this out of MetricsService.
+#include "chrome/browser/metrics/plugin_metrics_provider.h"
+#endif
+
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chromeos/system/statistics_provider.h"
 #endif
 
 #if defined(OS_WIN)
 #include <windows.h>  // Needed for STATUS_* codes
 #include "base/win/registry.h"
 #include "chrome/browser/metrics/google_update_metrics_provider_win.h"
 #endif
 
 #if defined(OS_ANDROID)
 // TODO(asvitkine): Move this out of MetricsService.
 #include "chrome/browser/metrics/android_metrics_provider.h"
 #endif
 
 using base::Time;
 using content::BrowserThread;
-using content::ChildProcessData;
-using content::PluginService;
 using metrics::MetricsLogManager;
 
 namespace {
 
 // Check to see that we're being called on only one thread.
 bool IsSingleThreaded() {
   static base::PlatformThreadId thread_id = 0;
   if (!thread_id)
     thread_id = base::PlatformThread::CurrentId();
   return base::PlatformThread::CurrentId() == thread_id;
@@ skipping 70 matching lines @@
 SyntheticTrialGroup::~SyntheticTrialGroup() {
 }
 
 // static
 MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
     MetricsService::CLEANLY_SHUTDOWN;
 
 MetricsService::ExecutionPhase MetricsService::execution_phase_ =
     MetricsService::UNINITIALIZED_PHASE;
 
-// This is used to quickly log stats from child process related notifications in
-// MetricsService::child_stats_buffer_.  The buffer's contents are transferred
-// out when Local State is periodically saved.  The information is then
-// reported to the UMA server on next launch.
-struct MetricsService::ChildProcessStats {
- public:
-  explicit ChildProcessStats(int process_type)
-      : process_launches(0),
-        process_crashes(0),
-        instances(0),
-        loading_errors(0),
-        process_type(process_type) {}
-
-  // This constructor is only used by the map to return some default value for
-  // an index for which no value has been assigned.
-  ChildProcessStats()
-      : process_launches(0),
-        process_crashes(0),
-        instances(0),
-        loading_errors(0),
-        process_type(content::PROCESS_TYPE_UNKNOWN) {}
-
-  // The number of times that the given child process has been launched
-  int process_launches;
-
-  // The number of times that the given child process has crashed
-  int process_crashes;
-
-  // The number of instances of this child process that have been created.
-  // An instance is a DOM object rendered by this child process during a page
-  // load.
-  int instances;
-
-  // The number of times there was an error loading an instance of this child
-  // process.
-  int loading_errors;
-
-  int process_type;
-};
-
 // static
 void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   DCHECK(IsSingleThreaded());
   metrics::MetricsStateManager::RegisterPrefs(registry);
 
   registry->RegisterInt64Pref(prefs::kStabilityLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kStabilityLastTimestampSec, 0);
   registry->RegisterStringPref(prefs::kStabilityStatsVersion, std::string());
   registry->RegisterInt64Pref(prefs::kStabilityStatsBuildTime, 0);
   registry->RegisterBooleanPref(prefs::kStabilityExitedCleanly, true);
@@ skipping 33 matching lines @@
   registry->RegisterInt64Pref(prefs::kUninstallMetricsPageLoadCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLaunchCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallMetricsUptimeSec, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLastLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLastObservedRunTimeSec, 0);
 
 #if defined(OS_ANDROID)
   // TODO(asvitkine): Move this out of here.
   AndroidMetricsProvider::RegisterPrefs(registry);
 #endif  // defined(OS_ANDROID)
+
+#if defined(ENABLE_PLUGINS)
+  // TODO(asvitkine): Move this out of here.
+  PluginMetricsProvider::RegisterPrefs(registry);
+#endif
 }
 
 MetricsService::MetricsService(metrics::MetricsStateManager* state_manager,
                                metrics::MetricsServiceClient* client)
     : log_manager_(g_browser_process->local_state(),
                    kUploadLogAvoidRetransmitSize),
       histogram_snapshot_manager_(this),
       state_manager_(state_manager),
       client_(client),
       recording_active_(false),
@@ skipping 24 matching lines @@
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider));
 
 #if defined(OS_WIN)
   google_update_metrics_provider_ = new GoogleUpdateMetricsProviderWin;
   RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider>(
       google_update_metrics_provider_));
 #endif
+
+#if defined(ENABLE_PLUGINS)
+  plugin_metrics_provider_ = new PluginMetricsProvider(
+      g_browser_process->local_state());
+  RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider>(
+      plugin_metrics_provider_));
+#endif
+
   BrowserChildProcessObserver::Add(this);
 }
 
 MetricsService::~MetricsService() {
   DisableRecording();
 
   BrowserChildProcessObserver::Remove(this);
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
@@ skipping 114 matching lines @@
     base::HistogramBase::Inconsistency problem) {
   UMA_HISTOGRAM_ENUMERATION("Histogram.InconsistenciesBrowserUnique",
                             problem, base::HistogramBase::NEVER_EXCEEDED_VALUE);
 }
 
 void MetricsService::InconsistencyDetectedInLoggedCount(int amount) {
   UMA_HISTOGRAM_COUNTS("Histogram.InconsistentSnapshotBrowser",
                        std::abs(amount));
 }
 
-void MetricsService::BrowserChildProcessHostConnected(
-    const content::ChildProcessData& data) {
-  GetChildProcessStats(data).process_launches++;
-}
-
 void MetricsService::BrowserChildProcessCrashed(
     const content::ChildProcessData& data) {
-  GetChildProcessStats(data).process_crashes++;
+  // TODO(asvitkine): Move this into ChromeStabilityStatsProvider.
+#if defined(ENABLE_PLUGINS)
   // Exclude plugin crashes from the count below because we report them via
   // a separate UMA metric.
-  if (!IsPluginProcess(data.process_type))
-    IncrementPrefValue(prefs::kStabilityChildProcessCrashCount);
-}
+  if (PluginMetricsProvider::IsPluginProcess(data.process_type))
+    return;
+#endif
 
-void MetricsService::BrowserChildProcessInstanceCreated(
-    const content::ChildProcessData& data) {
-  GetChildProcessStats(data).instances++;
+  IncrementPrefValue(prefs::kStabilityChildProcessCrashCount);
 }
 
 void MetricsService::HandleIdleSinceLastTransmission(bool in_idle) {
   // If there wasn't a lot of action, maybe the computer was asleep, in which
   // case, the log transmissions should have stopped.  Here we start them up
   // again.
   if (!in_idle && idle_since_last_transmission_)
     StartSchedulerIfNecessary();
   idle_since_last_transmission_ = in_idle;
 }
@@ skipping 209 matching lines @@
   target_loop->PostTask(FROM_HERE,
       base::Bind(&MetricsService::OnInitTaskGotHardwareClass,
           self, hardware_class));
 }
 
 void MetricsService::OnInitTaskGotHardwareClass(
     const std::string& hardware_class) {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
   hardware_class_ = hardware_class;
 
+  const base::Closure got_plugin_info_callback =
+      base::Bind(&MetricsService::OnInitTaskGotPluginInfo,
+                 self_ptr_factory_.GetWeakPtr());
+
 #if defined(ENABLE_PLUGINS)
-  // Start the next part of the init task: loading plugin information.
-  PluginService::GetInstance()->GetPlugins(
-      base::Bind(&MetricsService::OnInitTaskGotPluginInfo,
-          self_ptr_factory_.GetWeakPtr()));
+  plugin_metrics_provider_->GetPluginInformation(got_plugin_info_callback);
 #else
-  std::vector<content::WebPluginInfo> plugin_list_empty;
-  OnInitTaskGotPluginInfo(plugin_list_empty);
-#endif  // defined(ENABLE_PLUGINS)
+  got_plugin_info_callback.Run();
+#endif
 }
 
-void MetricsService::OnInitTaskGotPluginInfo(
-    const std::vector<content::WebPluginInfo>& plugins) {
+void MetricsService::OnInitTaskGotPluginInfo() {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
-  plugins_ = plugins;
 
   const base::Closure got_metrics_callback =
       base::Bind(&MetricsService::OnInitTaskGotGoogleUpdateData,
                  self_ptr_factory_.GetWeakPtr());
 
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
   google_update_metrics_provider_->GetGoogleUpdateData(got_metrics_callback);
 #else
   got_metrics_callback.Run();
 #endif
@@ skipping 146 matching lines @@
 
   // Put incremental data (histogram deltas, and realtime stats deltas) at the
   // end of all log transmissions (initial log handles this separately).
   // RecordIncrementalStabilityElements only exists on the derived
   // MetricsLog class.
   MetricsLog* current_log =
       static_cast<MetricsLog*>(log_manager_.current_log());
   DCHECK(current_log);
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
-  current_log->RecordEnvironment(metrics_providers_.get(), plugins_,
-                                 synthetic_trials);
+  current_log->RecordEnvironment(metrics_providers_.get(), synthetic_trials);
   PrefService* pref = g_browser_process->local_state();
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(pref, &incremental_uptime, &uptime);
   current_log->RecordStabilityMetrics(metrics_providers_.get(),
                                       incremental_uptime, uptime);
 
   RecordCurrentHistograms();
   current_log->RecordGeneralMetrics(metrics_providers_.get());
 
@@ skipping 197 matching lines @@
 
   has_initial_stability_log_ = true;
 }
 
 void MetricsService::PrepareInitialMetricsLog() {
   DCHECK(state_ == INIT_TASK_DONE || state_ == SENDING_INITIAL_STABILITY_LOG);
   initial_metrics_log_->set_hardware_class(hardware_class_);
 
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
-  initial_metrics_log_->RecordEnvironment(metrics_providers_.get(), plugins_,
+  initial_metrics_log_->RecordEnvironment(metrics_providers_.get(),
                                           synthetic_trials);
   PrefService* pref = g_browser_process->local_state();
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(pref, &incremental_uptime, &uptime);
 
   // Histograms only get written to the current log, so make the new log current
   // before writing them.
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(
@@ skipping 273 matching lines @@
     IncrementPrefValue(prefs::kStabilitySystemUncleanShutdownCount);
   else
     NOTREACHED() << "Unexpected Chrome OS crash type " << crash_type;
   // Wake up metrics logs sending if necessary now that new
   // log data is available.
   HandleIdleSinceLastTransmission(false);
 }
 #endif  // OS_CHROMEOS
 
 void MetricsService::LogPluginLoadingError(const base::FilePath& plugin_path) {
-  content::WebPluginInfo plugin;
-  bool success =
-      content::PluginService::GetInstance()->GetPluginInfoByPath(plugin_path,
-                                                                 &plugin);
-  DCHECK(success);
-  ChildProcessStats& stats = child_process_stats_buffer_[plugin.name];
-  // Initialize the type if this entry is new.
-  if (stats.process_type == content::PROCESS_TYPE_UNKNOWN) {
-    // The plug-in process might not actually of type PLUGIN (which means
-    // NPAPI), but we only care that it is *a* plug-in process.
-    stats.process_type = content::PROCESS_TYPE_PLUGIN;
-  } else {
-    DCHECK(IsPluginProcess(stats.process_type));
-  }
-  stats.loading_errors++;
-}
-
-MetricsService::ChildProcessStats& MetricsService::GetChildProcessStats(
-    const content::ChildProcessData& data) {
-  const base::string16& child_name = data.name;
-  if (!ContainsKey(child_process_stats_buffer_, child_name)) {
-    child_process_stats_buffer_[child_name] =
-        ChildProcessStats(data.process_type);
-  }
-  return child_process_stats_buffer_[child_name];
-}
-
-void MetricsService::RecordPluginChanges(PrefService* pref) {
-  ListPrefUpdate update(pref, prefs::kStabilityPluginStats);
-  base::ListValue* plugins = update.Get();
-  DCHECK(plugins);
-
-  for (base::ListValue::iterator value_iter = plugins->begin();
-       value_iter != plugins->end(); ++value_iter) {
-    if (!(*value_iter)->IsType(base::Value::TYPE_DICTIONARY)) {
-      NOTREACHED();
-      continue;
-    }
-
-    base::DictionaryValue* plugin_dict =
-        static_cast<base::DictionaryValue*>(*value_iter);
-    std::string plugin_name;
-    plugin_dict->GetString(prefs::kStabilityPluginName, &plugin_name);
-    if (plugin_name.empty()) {
-      NOTREACHED();
-      continue;
-    }
-
-    // TODO(viettrungluu): remove conversions
-    base::string16 name16 = base::UTF8ToUTF16(plugin_name);
-    if (child_process_stats_buffer_.find(name16) ==
-        child_process_stats_buffer_.end()) {
-      continue;
-    }
-
-    ChildProcessStats stats = child_process_stats_buffer_[name16];
-    if (stats.process_launches) {
-      int launches = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches);
-      launches += stats.process_launches;
-      plugin_dict->SetInteger(prefs::kStabilityPluginLaunches, launches);
-    }
-    if (stats.process_crashes) {
-      int crashes = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes);
-      crashes += stats.process_crashes;
-      plugin_dict->SetInteger(prefs::kStabilityPluginCrashes, crashes);
-    }
-    if (stats.instances) {
-      int instances = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances);
-      instances += stats.instances;
-      plugin_dict->SetInteger(prefs::kStabilityPluginInstances, instances);
-    }
-    if (stats.loading_errors) {
-      int loading_errors = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginLoadingErrors,
-                              &loading_errors);
-      loading_errors += stats.loading_errors;
-      plugin_dict->SetInteger(prefs::kStabilityPluginLoadingErrors,
-                              loading_errors);
-    }
-
-    child_process_stats_buffer_.erase(name16);
-  }
-
-  // Now go through and add dictionaries for plugins that didn't already have
-  // reports in Local State.
-  for (std::map<base::string16, ChildProcessStats>::iterator cache_iter =
-           child_process_stats_buffer_.begin();
-       cache_iter != child_process_stats_buffer_.end(); ++cache_iter) {
-    ChildProcessStats stats = cache_iter->second;
-
-    // Insert only plugins information into the plugins list.
-    if (!IsPluginProcess(stats.process_type))
-      continue;
-
-    // TODO(viettrungluu): remove conversion
-    std::string plugin_name = base::UTF16ToUTF8(cache_iter->first);
-
-    base::DictionaryValue* plugin_dict = new base::DictionaryValue;
-
-    plugin_dict->SetString(prefs::kStabilityPluginName, plugin_name);
-    plugin_dict->SetInteger(prefs::kStabilityPluginLaunches,
-                            stats.process_launches);
-    plugin_dict->SetInteger(prefs::kStabilityPluginCrashes,
-                            stats.process_crashes);
-    plugin_dict->SetInteger(prefs::kStabilityPluginInstances,
-                            stats.instances);
-    plugin_dict->SetInteger(prefs::kStabilityPluginLoadingErrors,
-                            stats.loading_errors);
-    plugins->Append(plugin_dict);
-  }
-  child_process_stats_buffer_.clear();
+#if defined(ENABLE_PLUGINS)
+  // TODO(asvitkine): Move this out of here.
+  plugin_metrics_provider_->LogPluginLoadingError(plugin_path);
+#endif
 }
 
 bool MetricsService::ShouldLogEvents() {
   // We simply don't log events to UMA if there is a single incognito
   // session visible. The problem is that we always notify using the orginal
   // profile in order to simplify notification processing.
   return !client_->IsOffTheRecordSessionActive();
 }
 
 void MetricsService::RecordBooleanPrefValue(const char* path, bool value) {
   DCHECK(IsSingleThreaded());
 
   PrefService* pref = g_browser_process->local_state();
   DCHECK(pref);
 
   pref->SetBoolean(path, value);
   RecordCurrentState(pref);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
-  RecordPluginChanges(pref);
+#if defined(ENABLE_PLUGINS)
+  plugin_metrics_provider_->RecordPluginChanges();
+#endif
 }
 
-// static
-bool MetricsService::IsPluginProcess(int process_type) {
-  return (process_type == content::PROCESS_TYPE_PLUGIN ||
-          process_type == content::PROCESS_TYPE_PPAPI_PLUGIN ||
-          process_type == content::PROCESS_TYPE_PPAPI_BROKER);
-}