Remove plugin_list param from MetricsLog::RecordStabilityMetrics.

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>
 
@@ skipping 406 matching lines @@
 void MetricsLog::set_version_extension(const std::string& extension) {
   g_version_extension.Get() = extension;
 }
 
 // static
 const std::string& MetricsLog::version_extension() {
   return g_version_extension.Get();
 }
 
 void MetricsLog::RecordStabilityMetrics(
-    const std::vector<content::WebPluginInfo>& plugin_list,
     base::TimeDelta incremental_uptime,
     LogType log_type) {
   DCHECK_NE(NO_LOG, log_type);
   DCHECK(!locked());
+  // Check UMA enabled date presence to ensure system profile has been filled.
+  DCHECK(uma_proto()->system_profile().has_uma_enabled_date());
 
   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(plugin_list, 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);
 
   // Omit some stats unless this is the initial stability log.
   if (log_type != INITIAL_LOG)
     return;
@@ skipping 43 matching lines @@
 int MetricsLog::GetScreenCount() const {
   // TODO(scottmg): NativeScreen maybe wrong. http://crbug.com/133312
   return gfx::Screen::GetNativeScreen()->GetNumDisplays();
 }
 
 void MetricsLog::GetFieldTrialIds(
     std::vector<ActiveGroupId>* field_trial_ids) const {
   chrome_variations::GetFieldTrialActiveGroupIds(field_trial_ids);
 }
 
-void MetricsLog::WritePluginStabilityElements(
-    const std::vector<content::WebPluginInfo>& plugin_list,
-    PrefService* pref) {
+void MetricsLog::WritePluginStabilityElements(PrefService* pref) {
   // Now log plugin stability info.
   const 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();
-  PluginPrefs* plugin_prefs = GetPluginPrefs();
   for (ListValue::const_iterator iter = plugin_stats_list->begin();
        iter != plugin_stats_list->end(); ++iter) {
     if (!(*iter)->IsType(Value::TYPE_DICTIONARY)) {
       NOTREACHED();
       continue;
     }
     DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*iter);
 
-    // Write the protobuf version.
     // 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 content::WebPluginInfo* plugin_info = NULL;
+    const SystemProfileProto::Plugin* system_profile_plugin = NULL;
     std::string plugin_name;
     plugin_dict->GetString(prefs::kStabilityPluginName, &plugin_name);
-    const string16 plugin_name_utf16 = UTF8ToUTF16(plugin_name);
-    for (std::vector<content::WebPluginInfo>::const_iterator iter =
-             plugin_list.begin();
-         iter != plugin_list.end(); ++iter) {
-      if (iter->name == plugin_name_utf16) {
-        plugin_info = &(*iter);
+    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 (!plugin_info) {
+    if (!system_profile_plugin) {
       NOTREACHED();
       continue;
     }
 
     SystemProfileProto::Stability::PluginStability* plugin_stability =
         stability->add_plugin_stability();
-    SetPluginInfo(*plugin_info, plugin_prefs,
-                  plugin_stability->mutable_plugin());
+    *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);
@@ skipping 28 matching lines @@
       uma_proto()->mutable_system_profile()->mutable_stability();
   stability->set_launch_count(launch_count);
   stability->set_crash_count(crash_count);
 }
 
 void MetricsLog::WriteRealtimeStabilityAttributes(
     PrefService* pref,
     base::TimeDelta incremental_uptime) {
   // Update the stats which are critical for real-time stability monitoring.
   // Since these are "optional," only list ones that are non-zero, as the counts
-  // are aggergated (summed) server side.
+  // are aggregated (summed) server side.
 
   SystemProfileProto::Stability* stability =
       uma_proto()->mutable_system_profile()->mutable_stability();
   int count = pref->GetInteger(prefs::kStabilityPageLoadCount);
   if (count) {
     stability->set_page_load_count(count);
     pref->SetInteger(prefs::kStabilityPageLoadCount, 0);
   }
 
   count = pref->GetInteger(prefs::kStabilityRendererCrashCount);
@@ skipping 340 matching lines @@
 
     // We invalidate the user count if it changed while the log was open.
     if (system_profile->has_multi_profile_user_count() &&
         user_count != system_profile->multi_profile_user_count())
       user_count = 0;
 
     system_profile->set_multi_profile_user_count(user_count);
   }
 }
 #endif