Create PluginMetricsProvider class.

chrome/browser/metrics/metrics_log_unittest.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 <string>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/port.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
-#include "chrome/installer/util/google_update_settings.h"
 #include "components/metrics/metrics_hashes.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/proto/profiler_event.pb.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "components/variations/active_field_trials.h"
-#include "components/variations/metrics_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/process_type.h"
-#include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
 #include "url/gurl.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/metrics/metrics_log_chromeos.h"
@@ skipping 45 matching lines @@
 const variations::ActiveGroupId kFieldTrialIds[] = {
   {37, 43},
   {13, 47},
   {23, 17}
 };
 const variations::ActiveGroupId kSyntheticTrials[] = {
   {55, 15},
   {66, 16}
 };
 
-#if defined(ENABLE_PLUGINS)
-content::WebPluginInfo CreateFakePluginInfo(
-    const std::string& name,
-    const base::FilePath::CharType* path,
-    const std::string& version,
-    bool is_pepper) {
-  content::WebPluginInfo plugin(base::UTF8ToUTF16(name),
-                                base::FilePath(path),
-                                base::UTF8ToUTF16(version),
-                                base::string16());
-  if (is_pepper)
-    plugin.type = content::WebPluginInfo::PLUGIN_TYPE_PEPPER_IN_PROCESS;
-  else
-    plugin.type = content::WebPluginInfo::PLUGIN_TYPE_NPAPI;
-  return plugin;
-}
-#endif  // defined(ENABLE_PLUGINS)
-
 #if defined(OS_CHROMEOS)
 class TestMetricsLogChromeOS : public MetricsLogChromeOS {
  public:
   explicit TestMetricsLogChromeOS(
       metrics::ChromeUserMetricsExtension* uma_proto)
       : MetricsLogChromeOS(uma_proto) {
   }
 };
 #endif  // OS_CHROMEOS
 
@@ skipping 177 matching lines @@
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsLogTest);
 };
 
 TEST_F(MetricsLogTest, RecordEnvironment) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
 
-  std::vector<content::WebPluginInfo> plugins;
   std::vector<variations::ActiveGroupId> synthetic_trials;
   // Add two synthetic trials.
   synthetic_trials.push_back(kSyntheticTrials[0]);
   synthetic_trials.push_back(kSyntheticTrials[1]);
 
   log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
-                        plugins, synthetic_trials);
+                        synthetic_trials);
   // Check that the system profile on the log has the correct values set.
   CheckSystemProfile(log.system_profile());
 
   // Check that the system profile has also been written to prefs.
   PrefService* local_state = log.GetPrefService();
   const std::string base64_system_profile =
       local_state->GetString(prefs::kStabilitySavedSystemProfile);
   EXPECT_FALSE(base64_system_profile.empty());
   std::string serialied_system_profile;
   EXPECT_TRUE(base::Base64Decode(base64_system_profile,
@@ skipping 13 matching lines @@
   // The pref value is empty, so loading it from prefs should fail.
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     EXPECT_FALSE(log.LoadSavedEnvironmentFromPrefs());
   }
 
   // Do a RecordEnvironment() call and check whether the pref is recorded.
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
-                          std::vector<content::WebPluginInfo>(),
                           std::vector<variations::ActiveGroupId>());
     EXPECT_FALSE(prefs.GetString(kSystemProfilePref).empty());
     EXPECT_FALSE(prefs.GetString(kSystemProfileHashPref).empty());
   }
 
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     EXPECT_TRUE(log.LoadSavedEnvironmentFromPrefs());
     // Check some values in the system profile.
     EXPECT_EQ(kInstallDateExpected, log.system_profile().install_date());
     EXPECT_EQ(kEnabledDateExpected, log.system_profile().uma_enabled_date());
     // Ensure that the call cleared the prefs.
     EXPECT_TRUE(prefs.GetString(kSystemProfilePref).empty());
     EXPECT_TRUE(prefs.GetString(kSystemProfileHashPref).empty());
   }
 
   // Ensure that a non-matching hash results in the pref being invalid.
   {
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     // Call RecordEnvironment() to record the pref again.
     log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
-                          std::vector<content::WebPluginInfo>(),
                           std::vector<variations::ActiveGroupId>());
   }
 
   {
     // Set the hash to a bad value.
     prefs.SetString(kSystemProfileHashPref, "deadbeef");
     TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG, &prefs);
     EXPECT_FALSE(log.LoadSavedEnvironmentFromPrefs());
     // Ensure that the prefs are cleared, even if the call failed.
     EXPECT_TRUE(prefs.GetString(kSystemProfilePref).empty());
     EXPECT_TRUE(prefs.GetString(kSystemProfileHashPref).empty());
   }
 }
 
 TEST_F(MetricsLogTest, InitialLogStabilityMetrics) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::INITIAL_STABILITY_LOG);
   std::vector<metrics::MetricsProvider*> metrics_providers;
   log.RecordEnvironment(metrics_providers,
-                        std::vector<content::WebPluginInfo>(),
                         std::vector<variations::ActiveGroupId>());
   log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
                              base::TimeDelta());
   const metrics::SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   // Required metrics:
   EXPECT_TRUE(stability.has_launch_count());
   EXPECT_TRUE(stability.has_crash_count());
   // Initial log metrics:
   EXPECT_TRUE(stability.has_incomplete_shutdown_count());
   EXPECT_TRUE(stability.has_breakpad_registration_success_count());
   EXPECT_TRUE(stability.has_breakpad_registration_failure_count());
   EXPECT_TRUE(stability.has_debugger_present_count());
   EXPECT_TRUE(stability.has_debugger_not_present_count());
 }
 
 TEST_F(MetricsLogTest, OngoingLogStabilityMetrics) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   std::vector<metrics::MetricsProvider*> metrics_providers;
   log.RecordEnvironment(metrics_providers,
-                        std::vector<content::WebPluginInfo>(),
                         std::vector<variations::ActiveGroupId>());
   log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
                              base::TimeDelta());
   const metrics::SystemProfileProto_Stability& stability =
       log.system_profile().stability();
   // Required metrics:
   EXPECT_TRUE(stability.has_launch_count());
   EXPECT_TRUE(stability.has_crash_count());
   // Initial log metrics:
   EXPECT_FALSE(stability.has_incomplete_shutdown_count());
   EXPECT_FALSE(stability.has_breakpad_registration_success_count());
   EXPECT_FALSE(stability.has_breakpad_registration_failure_count());
   EXPECT_FALSE(stability.has_debugger_present_count());
   EXPECT_FALSE(stability.has_debugger_not_present_count());
 }
 
-#if defined(ENABLE_PLUGINS)
-TEST_F(MetricsLogTest, Plugins) {
-  TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
-  std::vector<metrics::MetricsProvider*> metrics_providers;
-
-  std::vector<content::WebPluginInfo> plugins;
-  plugins.push_back(CreateFakePluginInfo("p1", FILE_PATH_LITERAL("p1.plugin"),
-                                         "1.5", true));
-  plugins.push_back(CreateFakePluginInfo("p2", FILE_PATH_LITERAL("p2.plugin"),
-                                         "2.0", false));
-  log.RecordEnvironment(metrics_providers, plugins,
-                        std::vector<variations::ActiveGroupId>());
-
-  const metrics::SystemProfileProto& system_profile = log.system_profile();
-  ASSERT_EQ(2, system_profile.plugin_size());
-  EXPECT_EQ("p1", system_profile.plugin(0).name());
-  EXPECT_EQ("p1.plugin", system_profile.plugin(0).filename());
-  EXPECT_EQ("1.5", system_profile.plugin(0).version());
-  EXPECT_TRUE(system_profile.plugin(0).is_pepper());
-  EXPECT_EQ("p2", system_profile.plugin(1).name());
-  EXPECT_EQ("p2.plugin", system_profile.plugin(1).filename());
-  EXPECT_EQ("2.0", system_profile.plugin(1).version());
-  EXPECT_FALSE(system_profile.plugin(1).is_pepper());
-
-  // Now set some plugin stability stats for p2 and verify they're recorded.
-  scoped_ptr<base::DictionaryValue> plugin_dict(new base::DictionaryValue);
-  plugin_dict->SetString(prefs::kStabilityPluginName, "p2");
-  plugin_dict->SetInteger(prefs::kStabilityPluginLaunches, 1);
-  plugin_dict->SetInteger(prefs::kStabilityPluginCrashes, 2);
-  plugin_dict->SetInteger(prefs::kStabilityPluginInstances, 3);
-  plugin_dict->SetInteger(prefs::kStabilityPluginLoadingErrors, 4);
-  {
-    ListPrefUpdate update(log.GetPrefService(), prefs::kStabilityPluginStats);
-    update.Get()->Append(plugin_dict.release());
-  }
-
-  log.RecordStabilityMetrics(metrics_providers, base::TimeDelta(),
-                             base::TimeDelta());
-  const metrics::SystemProfileProto_Stability& stability =
-      log.system_profile().stability();
-  ASSERT_EQ(1, stability.plugin_stability_size());
-  EXPECT_EQ("p2", stability.plugin_stability(0).plugin().name());
-  EXPECT_EQ("p2.plugin", stability.plugin_stability(0).plugin().filename());
-  EXPECT_EQ("2.0", stability.plugin_stability(0).plugin().version());
-  EXPECT_FALSE(stability.plugin_stability(0).plugin().is_pepper());
-  EXPECT_EQ(1, stability.plugin_stability(0).launch_count());
-  EXPECT_EQ(2, stability.plugin_stability(0).crash_count());
-  EXPECT_EQ(3, stability.plugin_stability(0).instance_count());
-  EXPECT_EQ(4, stability.plugin_stability(0).loading_error_count());
-}
-#endif  // defined(ENABLE_PLUGINS)
-
 // Test that we properly write profiler data to the log.
 TEST_F(MetricsLogTest, RecordProfilerData) {
   // WARNING: If you broke the below check, you've modified how
   // metrics::HashMetricName works. Please also modify all server-side code that
   // relies on the existing way of hashing.
   EXPECT_EQ(GG_UINT64_C(1518842999910132863),
             metrics::HashMetricName("birth_thread*"));
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   EXPECT_EQ(0, log.uma_proto().profiler_event_size());
@@ skipping 171 matching lines @@
   chromeos::ScopedUserManagerEnabler scoped_enabler(user_manager);
   user_manager->AddKioskAppUser(user1);
   user_manager->AddKioskAppUser(user2);
   user_manager->AddKioskAppUser(user3);
 
   user_manager->LoginUser(user1);
   user_manager->LoginUser(user3);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   std::vector<metrics::MetricsProvider*> metrics_providers;
-  std::vector<content::WebPluginInfo> plugins;
   std::vector<variations::ActiveGroupId> synthetic_trials;
-  log.RecordEnvironment(metrics_providers, plugins, synthetic_trials);
+  log.RecordEnvironment(metrics_providers, synthetic_trials);
   EXPECT_EQ(2u, log.system_profile().multi_profile_user_count());
 }
 
 TEST_F(MetricsLogTest, MultiProfileCountInvalidated) {
   std::string user1("user1@example.com");
   std::string user2("user2@example.com");
   std::string user3("user3@example.com");
 
   // |scoped_enabler| takes over the lifetime of |user_manager|.
   chromeos::FakeUserManager* user_manager = new chromeos::FakeUserManager();
   chromeos::ScopedUserManagerEnabler scoped_enabler(user_manager);
   user_manager->AddKioskAppUser(user1);
   user_manager->AddKioskAppUser(user2);
   user_manager->AddKioskAppUser(user3);
 
   user_manager->LoginUser(user1);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   EXPECT_EQ(1u, log.system_profile().multi_profile_user_count());
 
   user_manager->LoginUser(user2);
   std::vector<metrics::MetricsProvider*> metrics_providers;
   std::vector<variations::ActiveGroupId> synthetic_trials;
-  log.RecordEnvironment(metrics_providers,
-                        std::vector<content::WebPluginInfo>(),
-                        synthetic_trials);
+  log.RecordEnvironment(metrics_providers, synthetic_trials);
   EXPECT_EQ(0u, log.system_profile().multi_profile_user_count());
 }
 
 TEST_F(MetricsLogTest, BluetoothHardwareDisabled) {
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
-                        std::vector<content::WebPluginInfo>(),
                         std::vector<variations::ActiveGroupId>());
 
   EXPECT_TRUE(log.system_profile().has_hardware());
   EXPECT_TRUE(log.system_profile().hardware().has_bluetooth());
 
   EXPECT_TRUE(log.system_profile().hardware().bluetooth().is_present());
   EXPECT_FALSE(log.system_profile().hardware().bluetooth().is_enabled());
 }
 
 TEST_F(MetricsLogTest, BluetoothHardwareEnabled) {
   FakeBluetoothAdapterClient::Properties* properties =
       fake_bluetooth_adapter_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
   properties->powered.ReplaceValue(true);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
-                        std::vector<content::WebPluginInfo>(),
                         std::vector<variations::ActiveGroupId>());
 
   EXPECT_TRUE(log.system_profile().has_hardware());
   EXPECT_TRUE(log.system_profile().hardware().has_bluetooth());
 
   EXPECT_TRUE(log.system_profile().hardware().bluetooth().is_present());
   EXPECT_TRUE(log.system_profile().hardware().bluetooth().is_enabled());
 }
 
 TEST_F(MetricsLogTest, BluetoothPairedDevices) {
   // The fake bluetooth adapter class already claims to be paired with one
   // device when initialized. Add a second and third fake device to it so we
   // can test the cases where a device is not paired (LE device, generally)
   // and a device that does not have Device ID information.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
 
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
 
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   properties->paired.ReplaceValue(true);
 
   TestMetricsLog log(kClientId, kSessionId, MetricsLog::ONGOING_LOG);
   log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
-                        std::vector<content::WebPluginInfo>(),
                         std::vector<variations::ActiveGroupId>());
 
   ASSERT_TRUE(log.system_profile().has_hardware());
   ASSERT_TRUE(log.system_profile().hardware().has_bluetooth());
 
   // Only two of the devices should appear.
   EXPECT_EQ(2,
             log.system_profile().hardware().bluetooth().paired_device_size());
 
   typedef metrics::SystemProfileProto::Hardware::Bluetooth::PairedDevice
@@ skipping 18 matching lines @@
   PairedDevice device2 =
       log.system_profile().hardware().bluetooth().paired_device(1);
 
   EXPECT_EQ(FakeBluetoothDeviceClient::kConfirmPasskeyClass,
             device2.bluetooth_class());
   EXPECT_EQ(PairedDevice::DEVICE_PHONE, device2.type());
   EXPECT_EQ(0x207D74U, device2.vendor_prefix());
   EXPECT_EQ(PairedDevice::VENDOR_ID_UNKNOWN, device2.vendor_id_source());
 }
 #endif  // OS_CHROMEOS