CPM Refactor and Cleanup

chrome/browser/performance_monitor/performance_monitor_browsertest.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/test/base/in_process_browser_test.h"
-
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_service.h"
+#include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_service_test_helper.h"
-#include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/browser_tabstrip.h"
-#include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 201 matching lines @@
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(base::IgnoreResult(&Database::AddStateValue),
                    base::Unretained(performance_monitor()->database()),
                    key,
                    value));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
   }
 
+  // A handle for PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread();
+  // we mock synchronicity with FlushForTesting().
+  void CheckForVersionUpdate() {
+    content::BrowserThread::PostBlockingPoolSequencedTask(
+        Database::kDatabaseSequenceToken,
+        FROM_HERE,
+        base::Bind(&PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread,
+                   base::Unretained(performance_monitor())));
+
+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+  }
+
   PerformanceMonitor* performance_monitor() const {
     return performance_monitor_;
   }
 
  protected:
   ScopedTempDir db_dir_;
   PerformanceMonitor* performance_monitor_;
 };
 
 class PerformanceMonitorUncleanExitBrowserTest
@@ skipping 135 matching lines @@
                                  .AppendASCII("extensions")
                                  .AppendASCII("simple_extension_v1");
   const Extension* extension = LoadExtension(extension_path);
 
   DisableExtension(extension->id());
   EnableExtension(extension->id());
 
   std::vector<ExtensionBasicInfo> extension_infos;
   // There will be three events in all, each pertaining to the same extension:
   //   Extension Install
-  //   Extension Unload
+  //   Extension Disable
   //   Extension Enable
   for (int i = 0; i < kNumEvents; ++i)
     extension_infos.push_back(ExtensionBasicInfo(extension));
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
-  expected_event_types.push_back(EVENT_EXTENSION_UNLOAD);
+  expected_event_types.push_back(EVENT_EXTENSION_DISABLE);
   expected_event_types.push_back(EVENT_EXTENSION_ENABLE);
 
   std::vector<linked_ptr<Event> > events = GetEvents();
   CheckExtensionEvents(expected_event_types, events, extension_infos);
-
-  // There will be an additional field on the unload event: Unload Reason.
-  int unload_reason = -1;
-  ASSERT_TRUE(events[1]->data()->GetInteger("unloadReason", &unload_reason));
-  ASSERT_EQ(extension_misc::UNLOAD_REASON_DISABLE, unload_reason);
 }
 
 // Test that PerformanceMonitor correctly records an extension update event.
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, UpdateExtensionEvent) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   FilePath test_data_dir;
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
   test_data_dir = test_data_dir.AppendASCII("performance_monitor")
@@ skipping 29 matching lines @@
   ASSERT_TRUE(extension_service->
       UpdateExtension(extension->id(), path_v2_, GURL(), &crx_installer));
   windowed_observer.Wait();
 
   extension = extension_service->GetExtensionById(
       extension_infos[0].id, false); // don't include disabled extensions.
 
   // The total series of events for this process will be:
   //   Extension Install - install version 1
   //   Extension Install - install version 2
-  //   Extension Unload  - disable version 1
   //   Extension Update  - signal the udate to version 2
   // We push back the corresponding ExtensionBasicInfos.
   extension_infos.push_back(ExtensionBasicInfo(extension));
-  extension_infos.push_back(extension_infos[0]);
   extension_infos.push_back(extension_infos[1]);
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
-  expected_event_types.push_back(EVENT_EXTENSION_UNLOAD);
   expected_event_types.push_back(EVENT_EXTENSION_UPDATE);
 
   std::vector<linked_ptr<Event> > events = GetEvents();
 
   CheckExtensionEvents(expected_event_types, events, extension_infos);
-
-  // There will be an additional field: The unload reason.
-  int unload_reason = -1;
-  ASSERT_TRUE(events[2]->data()->GetInteger("unloadReason", &unload_reason));
-  ASSERT_EQ(extension_misc::UNLOAD_REASON_UPDATE, unload_reason);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, UninstallExtensionEvent) {
-  const int kNumEvents = 3;
+  const int kNumEvents = 2;
   FilePath extension_path;
   PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
   extension_path = extension_path.AppendASCII("performance_monitor")
                                  .AppendASCII("extensions")
                                  .AppendASCII("simple_extension_v1");
   const Extension* extension = LoadExtension(extension_path);
 
   std::vector<ExtensionBasicInfo> extension_infos;
-  // There will be three events in all, each pertaining to the same extension:
+  // There will be two events, both pertaining to the same extension:
   //   Extension Install
-  //   Extension Disable (Unload)
   //   Extension Uninstall
   for (int i = 0; i < kNumEvents; ++i)
     extension_infos.push_back(ExtensionBasicInfo(extension));
 
   UninstallExtension(extension->id());
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
-  expected_event_types.push_back(EVENT_EXTENSION_UNLOAD);
   expected_event_types.push_back(EVENT_EXTENSION_UNINSTALL);
 
   std::vector<linked_ptr<Event> > events = GetEvents();
 
   CheckExtensionEvents(expected_event_types, events, extension_infos);
-
-  // There will be an additional field: The unload reason.
-  int unload_reason = -1;
-  ASSERT_TRUE(events[1]->data()->GetInteger("unloadReason", &unload_reason));
-  ASSERT_EQ(extension_misc::UNLOAD_REASON_UNINSTALL, unload_reason);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, NewVersionEvent) {
   const char kOldVersion[] = "0.0";
 
   // The version in the database right now will be the current version of chrome
   // (gathered at initialization of PerformanceMonitor). Replace this with an
   // older version so an event is generated.
   AddStateValue(kStateChromeVersion, kOldVersion);
 
-  content::BrowserThread::PostBlockingPoolSequencedTask(
-      Database::kDatabaseSequenceToken,
-      FROM_HERE,
-      base::Bind(&PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread,
-                 base::Unretained(performance_monitor())));
-
-  // Wait for event insertion.
-  content::BrowserThread::GetBlockingPool()->FlushForTesting();
+  CheckForVersionUpdate();
 
   chrome::VersionInfo version;
   ASSERT_TRUE(version.is_valid());
   std::string version_string = version.Version();
 
   std::vector<linked_ptr<Event> > events = GetEvents();
   ASSERT_EQ(1u, events.size());
   ASSERT_EQ(EVENT_CHROME_UPDATE, events[0]->type());
 
   const base::DictionaryValue* value;
@@ skipping 18 matching lines @@
 
   stats = GetStats(METRIC_PRIVATE_MEMORY_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
 
   stats = GetStats(METRIC_SHARED_MEMORY_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
 
   // Open new tabs to incur CPU usage.
-  for (int i = 0; i < 3; ++i) {
-    chrome::NavigateParams params(browser(), GURL("http://www.google.com"),
+  for (int i = 0; i < 10; ++i) {
+    chrome::NavigateParams params(
+        browser(),
+        ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
+                                  FilePath(FILE_PATH_LITERAL("title1.html"))),
                                   content::PAGE_TRANSITION_LINK);
     params.disposition = NEW_BACKGROUND_TAB;
     ui_test_utils::NavigateToURL(&params);
   }
   GatherStatistics();
 
   // One CPUUsage stat should exist now.
   stats = GetStats(METRIC_CPU_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
@@ skipping 114 matching lines @@
   Database::MetricInfoVector metrics = GetStats(METRIC_TEST_STARTUP_TIME);
   ASSERT_EQ(1u, metrics.size());
   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
 
   metrics = GetStats(METRIC_SESSION_RESTORE_TIME);
   ASSERT_EQ(1u, metrics.size());
   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
 }
 
 }  // namespace performance_monitor