Create PluginMetricsProvider class.

chrome/browser/metrics/metrics_log.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/metrics/metrics_log.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/cpu.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/third_party/nspr/prtime.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/extension_metrics.h"
-#include "chrome/browser/plugins/plugin_prefs.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/proto/profiler_event.pb.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/variations/active_field_trials.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_client.h"
-#include "content/public/common/webplugininfo.h"
 #include "gpu/config/gpu_info.h"
 #include "ui/gfx/screen.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
@@ skipping 58 matching lines @@
       return ProfilerEventProto::TrackedObject::UNKNOWN;
   }
 }
 
 // Computes a SHA-1 hash of |data| and returns it as a hex string.
 std::string ComputeSHA1(const std::string& data) {
   const std::string sha1 = base::SHA1HashString(data);
   return base::HexEncode(sha1.data(), sha1.size());
 }
 
-#if defined(ENABLE_PLUGINS)
-// Returns the plugin preferences corresponding for this user, if available.
-// If multiple user profiles are loaded, returns the preferences corresponding
-// to an arbitrary one of the profiles.
-PluginPrefs* GetPluginPrefs() {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-
-  if (!profile_manager) {
-    // The profile manager can be NULL when testing.
-    return NULL;
-  }
-
-  std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
-  if (profiles.empty())
-    return NULL;
-
-  return PluginPrefs::GetForProfile(profiles.front()).get();
-}
-
-// Fills |plugin| with the info contained in |plugin_info| and |plugin_prefs|.
-void SetPluginInfo(const content::WebPluginInfo& plugin_info,
-                   const PluginPrefs* plugin_prefs,
-                   SystemProfileProto::Plugin* plugin) {
-  plugin->set_name(base::UTF16ToUTF8(plugin_info.name));
-  plugin->set_filename(plugin_info.path.BaseName().AsUTF8Unsafe());
-  plugin->set_version(base::UTF16ToUTF8(plugin_info.version));
-  plugin->set_is_pepper(plugin_info.is_pepper_plugin());
-  if (plugin_prefs)
-    plugin->set_is_disabled(!plugin_prefs->IsPluginEnabled(plugin_info));
-}
-#endif  // defined(ENABLE_PLUGINS)
-
 void WriteFieldTrials(const std::vector<ActiveGroupId>& field_trial_ids,
                       SystemProfileProto* system_profile) {
   for (std::vector<ActiveGroupId>::const_iterator it =
        field_trial_ids.begin(); it != field_trial_ids.end(); ++it) {
     SystemProfileProto::FieldTrial* field_trial =
         system_profile->add_field_trial();
     field_trial->set_name_id(it->name);
     field_trial->set_group_id(it->group);
   }
 }
@@ skipping 112 matching lines @@
       extension_metrics_(uma_proto()->client_id()) {
   uma_proto()->mutable_system_profile()->set_channel(client_->GetChannel());
 
 #if defined(OS_CHROMEOS)
   metrics_log_chromeos_.reset(new MetricsLogChromeOS(uma_proto()));
 #endif  // OS_CHROMEOS
 }
 
 MetricsLog::~MetricsLog() {}
 
-// static
-void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterListPref(prefs::kStabilityPluginStats);
-}
-
 void MetricsLog::RecordStabilityMetrics(
     const std::vector<metrics::MetricsProvider*>& metrics_providers,
     base::TimeDelta incremental_uptime,
     base::TimeDelta uptime) {
   DCHECK(!locked());
   DCHECK(HasEnvironment());
   DCHECK(!HasStabilityMetrics());
 
   PrefService* pref = GetPrefService();
   DCHECK(pref);
 
   // Get stability attributes out of Local State, zeroing out stored values.
   // NOTE: This could lead to some data loss if this report isn't successfully
   //       sent, but that's true for all the metrics.
 
   WriteRequiredStabilityAttributes(pref);
-  WritePluginStabilityElements(pref);
 
   // Record recent delta for critical stability metrics.  We can't wait for a
   // restart to gather these, as that delay biases our observation away from
   // users that run happily for a looooong time.  We send increments with each
   // uma log upload, just as we send histogram data.
   WriteRealtimeStabilityAttributes(pref, incremental_uptime, uptime);
 
-  SystemProfileProto::Stability* stability =
-      uma_proto()->mutable_system_profile()->mutable_stability();
+  SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
   for (size_t i = 0; i < metrics_providers.size(); ++i)
-    metrics_providers[i]->ProvideStabilityMetrics(stability);
+    metrics_providers[i]->ProvideStabilityMetrics(system_profile);
 
   // Omit some stats unless this is the initial stability log.
   if (log_type() != INITIAL_STABILITY_LOG)
     return;
 
   int incomplete_shutdown_count =
       pref->GetInteger(prefs::kStabilityIncompleteSessionEndCount);
   pref->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   int breakpad_registration_success_count =
       pref->GetInteger(prefs::kStabilityBreakpadRegistrationSuccess);
   pref->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0);
   int breakpad_registration_failure_count =
       pref->GetInteger(prefs::kStabilityBreakpadRegistrationFail);
   pref->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0);
   int debugger_present_count =
       pref->GetInteger(prefs::kStabilityDebuggerPresent);
   pref->SetInteger(prefs::kStabilityDebuggerPresent, 0);
   int debugger_not_present_count =
       pref->GetInteger(prefs::kStabilityDebuggerNotPresent);
   pref->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
 
   // TODO(jar): The following are all optional, so we *could* optimize them for
   // values of zero (and not include them).
+  SystemProfileProto::Stability* stability =
+      system_profile->mutable_stability();
   stability->set_incomplete_shutdown_count(incomplete_shutdown_count);
   stability->set_breakpad_registration_success_count(
       breakpad_registration_success_count);
   stability->set_breakpad_registration_failure_count(
       breakpad_registration_failure_count);
   stability->set_debugger_present_count(debugger_present_count);
   stability->set_debugger_not_present_count(debugger_not_present_count);
 }
 
 void MetricsLog::RecordGeneralMetrics(
@@ skipping 26 matching lines @@
 }
 
 bool MetricsLog::HasEnvironment() const {
   return uma_proto()->system_profile().has_uma_enabled_date();
 }
 
 bool MetricsLog::HasStabilityMetrics() const {
   return uma_proto()->system_profile().stability().has_launch_count();
 }
 
-void MetricsLog::WritePluginStabilityElements(PrefService* pref) {
-  // Now log plugin stability info.
-  const base::ListValue* plugin_stats_list = pref->GetList(
-      prefs::kStabilityPluginStats);
-  if (!plugin_stats_list)
-    return;
-
-#if defined(ENABLE_PLUGINS)
-  SystemProfileProto::Stability* stability =
-      uma_proto()->mutable_system_profile()->mutable_stability();
-  for (base::ListValue::const_iterator iter = plugin_stats_list->begin();
-       iter != plugin_stats_list->end(); ++iter) {
-    if (!(*iter)->IsType(base::Value::TYPE_DICTIONARY)) {
-      NOTREACHED();
-      continue;
-    }
-    base::DictionaryValue* plugin_dict =
-        static_cast<base::DictionaryValue*>(*iter);
-
-    // Note that this search is potentially a quadratic operation, but given the
-    // low number of plugins installed on a "reasonable" setup, this should be
-    // fine.
-    // TODO(isherman): Verify that this does not show up as a hotspot in
-    // profiler runs.
-    const SystemProfileProto::Plugin* system_profile_plugin = NULL;
-    std::string plugin_name;
-    plugin_dict->GetString(prefs::kStabilityPluginName, &plugin_name);
-    const SystemProfileProto& system_profile = uma_proto()->system_profile();
-    for (int i = 0; i < system_profile.plugin_size(); ++i) {
-      if (system_profile.plugin(i).name() == plugin_name) {
-        system_profile_plugin = &system_profile.plugin(i);
-        break;
-      }
-    }
-
-    if (!system_profile_plugin) {
-      NOTREACHED();
-      continue;
-    }
-
-    SystemProfileProto::Stability::PluginStability* plugin_stability =
-        stability->add_plugin_stability();
-    *plugin_stability->mutable_plugin() = *system_profile_plugin;
-
-    int launches = 0;
-    plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches);
-    if (launches > 0)
-      plugin_stability->set_launch_count(launches);
-
-    int instances = 0;
-    plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances);
-    if (instances > 0)
-      plugin_stability->set_instance_count(instances);
-
-    int crashes = 0;
-    plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes);
-    if (crashes > 0)
-      plugin_stability->set_crash_count(crashes);
-
-    int loading_errors = 0;
-    plugin_dict->GetInteger(prefs::kStabilityPluginLoadingErrors,
-                            &loading_errors);
-    if (loading_errors > 0)
-      plugin_stability->set_loading_error_count(loading_errors);
-  }
-#endif  // defined(ENABLE_PLUGINS)
-
-  pref->ClearPref(prefs::kStabilityPluginStats);
-}
-
 // The server refuses data that doesn't have certain values.  crashcount and
 // launchcount are currently "required" in the "stability" group.
 // TODO(isherman): Stop writing these attributes specially once the migration to
 // protobufs is complete.
 void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) {
   int launch_count = pref->GetInteger(prefs::kStabilityLaunchCount);
   pref->SetInteger(prefs::kStabilityLaunchCount, 0);
   int crash_count = pref->GetInteger(prefs::kStabilityCrashCount);
   pref->SetInteger(prefs::kStabilityCrashCount, 0);
 
@@ skipping 25 matching lines @@
 #endif  // OS_CHROMEOS
 
   const uint64 incremental_uptime_sec = incremental_uptime.InSeconds();
   if (incremental_uptime_sec)
     stability->set_incremental_uptime_sec(incremental_uptime_sec);
   const uint64 uptime_sec = uptime.InSeconds();
   if (uptime_sec)
     stability->set_uptime_sec(uptime_sec);
 }
 
-void MetricsLog::WritePluginList(
-    const std::vector<content::WebPluginInfo>& plugin_list) {
-  DCHECK(!locked());
-
-#if defined(ENABLE_PLUGINS)
-  PluginPrefs* plugin_prefs = GetPluginPrefs();
-  SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
-  for (std::vector<content::WebPluginInfo>::const_iterator iter =
-           plugin_list.begin();
-       iter != plugin_list.end(); ++iter) {
-    SystemProfileProto::Plugin* plugin = system_profile->add_plugin();
-    SetPluginInfo(*iter, plugin_prefs, plugin);
-  }
-#endif  // defined(ENABLE_PLUGINS)
-}
-
 void MetricsLog::RecordEnvironment(
     const std::vector<metrics::MetricsProvider*>& metrics_providers,
-    const std::vector<content::WebPluginInfo>& plugin_list,
     const std::vector<variations::ActiveGroupId>& synthetic_trials) {
   DCHECK(!HasEnvironment());
 
   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
 
   std::string brand_code;
   if (client_->GetBrand(&brand_code))
     system_profile->set_brand_code(brand_code);
 
   int enabled_date;
@@ skipping 59 matching lines @@
   const gfx::Size display_size = GetScreenSize();
   hardware->set_primary_screen_width(display_size.width());
   hardware->set_primary_screen_height(display_size.height());
   hardware->set_primary_screen_scale_factor(GetScreenDeviceScaleFactor());
   hardware->set_screen_count(GetScreenCount());
 
 #if defined(OS_WIN)
   WriteScreenDPIInformationProto(hardware);
 #endif
 
-  WritePluginList(plugin_list);
   extension_metrics_.WriteExtensionList(uma_proto()->mutable_system_profile());
 
   std::vector<ActiveGroupId> field_trial_ids;
   GetFieldTrialIds(&field_trial_ids);
   WriteFieldTrials(field_trial_ids, system_profile);
   WriteFieldTrials(synthetic_trials, system_profile);
 
 #if defined(OS_CHROMEOS)
   metrics_log_chromeos_->LogChromeOSMetrics();
 #endif  // OS_CHROMEOS
@@ skipping 49 matching lines @@
     profile = uma_proto()->add_profiler_event();
     profile->set_profile_type(ProfilerEventProto::STARTUP_PROFILE);
     profile->set_time_source(ProfilerEventProto::WALL_CLOCK_TIME);
   } else {
     // For the remaining calls, re-use the existing field.
     profile = uma_proto()->mutable_profiler_event(0);
   }
 
   WriteProfilerData(process_data, process_type, profile);
 }