Add Unclean Exit Watching to CPM

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/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/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/performance_monitor.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/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.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"
 
 using extensions::Extension;
@@ skipping 93 matching lines @@
 class PerformanceMonitorBrowserTest : public ExtensionBrowserTest {
  public:
   virtual void SetUpOnMainThread() OVERRIDE {
     CHECK(db_dir_.CreateUniqueTempDir());
     performance_monitor_ = PerformanceMonitor::GetInstance();
     performance_monitor_->SetDatabasePath(db_dir_.path());
     performance_monitor_->Start();
 
     // Wait for DB to finish setting up.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
+    ui_test_utils::RunAllPendingInMessageLoop();
   }
 
   void GetEventsOnBackgroundThread(std::vector<linked_ptr<Event> >* events) {
     *events = performance_monitor_->database()->GetEvents();
   }
 
   // A handle for getting the events from the database, which must be done on
   // the background thread. Since we are testing, we can mock synchronicity
   // with FlushForTesting().
   std::vector<linked_ptr<Event> > GetEvents() {
     std::vector<linked_ptr<Event> > events;
     content::BrowserThread::PostBlockingPoolSequencedTask(
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitorBrowserTest::GetEventsOnBackgroundThread,
                    base::Unretained(this),
                    &events));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     return events;
   }
 
+  void AddStateValue(const std::string& key, const std::string& value) {
+    content::BrowserThread::PostBlockingPoolSequencedTask(
+        Database::kDatabaseSequenceToken,
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&Database::AddStateValue),
+                   base::Unretained(performance_monitor()->database()),
+                   key,
+                   value));
+
+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+  }
+
   PerformanceMonitor* performance_monitor() const {
     return performance_monitor_;
   }
 
  protected:
   ScopedTempDir db_dir_;
   PerformanceMonitor* performance_monitor_;
 };
 
+class PerformanceMonitorUncleanExitBrowserTest
+    : public PerformanceMonitorBrowserTest {
+ public:
+  virtual bool SetUpUserDataDirectory() OVERRIDE {
+    FilePath user_data_directory;
+    PathService::Get(chrome::DIR_USER_DATA, &user_data_directory);
+
+    FilePath default_profile = user_data_directory.AppendASCII("Default");
+    CHECK(file_util::CreateDirectory(default_profile));
+
+    FilePath stock_prefs_file;
+    PathService::Get(chrome::DIR_TEST_DATA, &stock_prefs_file);
+    stock_prefs_file = stock_prefs_file.AppendASCII("performance_monitor")
+                                       .AppendASCII("unclean_exit_prefs");
+    CHECK(file_util::PathExists(stock_prefs_file));
+
+    FilePath default_profile_prefs_file =
+        default_profile.AppendASCII(chrome::kPreferencesFilename);
+    CHECK(file_util::CopyFile(stock_prefs_file, default_profile_prefs_file));
+    CHECK(file_util::PathExists(default_profile_prefs_file));
+
+    FilePath second_profile = user_data_directory.AppendASCII("Profile 1");
+    CHECK(file_util::CreateDirectory(second_profile));
+
+    FilePath second_profile_prefs_file =
+        second_profile.AppendASCII(chrome::kPreferencesFilename);
+    CHECK(file_util::CopyFile(stock_prefs_file, second_profile_prefs_file));
+    CHECK(file_util::PathExists(second_profile_prefs_file));
+
+    return true;
+  }
+};
+
 // Test that PerformanceMonitor will correctly record an extension installation
 // event.
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, InstallExtensionEvent) {
   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);
 
@@ skipping 114 matching lines @@
   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(PerformanceMonitorUncleanExitBrowserTest,
+                       OneProfileUncleanExit) {
+  const std::string profile_name = "Default";
+  const std::string time = "12985807272597591";
+  const size_t kNumEvents = 1;
+
+  // Initialize the database value (if there's no value in the database, it
+  // can't determine the last active time of the profile, and doesn't insert
+  // the event).
+  AddStateValue(kStateProfile + profile_name, time);
+
+  performance_monitor()->CheckForUncleanExit();
+
+  ui_test_utils::RunAllPendingInMessageLoop();
+
+  std::vector<linked_ptr<Event> > events = GetEvents();
+  ASSERT_EQ(kNumEvents, events.size());
+
+  CheckEvent(EVENT_UNCLEAN_EXIT, events[0]);
+
+  std::string event_profile;
+  ASSERT_TRUE(events[0]->data()->GetString("profileName", &event_profile));
+  ASSERT_EQ(profile_name, event_profile);
+}
+
+IN_PROC_BROWSER_TEST_F(PerformanceMonitorUncleanExitBrowserTest,
+                       TwoProfileUncleanExit) {

[Yoyo Zhou, 2012/07/10 02:35:06]

It looks like these tests are only testing one of the 2 paths by which we might
add an unclean exit event.

[Devlin, 2012/07/10 17:18:32]

I assume that by the "Two paths" you mean either at startup or through adding
the profile after startup (if this isn't right, please correct me). The second
test (TwoProfileUncleanExit) tests both of these paths. We init both profiles to
have an unclean exit, but only the first ("Default") is loaded at startup
(testing the first path). When we call ProfileManager::GetProfile(), it loads
the second profile and causes a PROFILE_ADDED notification, which is the second
path.

[Yoyo Zhou, 2012/07/12 18:13:44]

Yes, that's what I meant. Apparently I didn't read the test carefully enough, so
never mind; this is good.

+  const std::string profile1_name = "Default";
+  const std::string profile2_name = "Profile 1";
+  const std::string time1 = "12985807272597591";
+  const std::string time2 = "12985807272599918";
+  const size_t kNumEvents = 2;
+
+  FilePath profile2_path;
+  PathService::Get(chrome::DIR_USER_DATA, &profile2_path);
+  profile2_path = profile2_path.AppendASCII(profile2_name);
+
+  AddStateValue(kStateProfile + profile1_name, time1);
+  AddStateValue(kStateProfile + profile2_name, time2);
+
+  performance_monitor()->CheckForUncleanExit();
+  ui_test_utils::RunAllPendingInMessageLoop();
+
+  // Load the second profile, which has also exited uncleanly.
+  g_browser_process->profile_manager()->GetProfile(profile2_path);
+  ui_test_utils::RunAllPendingInMessageLoop();
+
+  std::vector<linked_ptr<Event> > events = GetEvents();
+
+  ASSERT_EQ(kNumEvents, events.size());
+  CheckEvent(EVENT_UNCLEAN_EXIT, events[0]);
+  CheckEvent(EVENT_UNCLEAN_EXIT, events[1]);
+
+  std::string event_profile;
+  ASSERT_TRUE(events[0]->data()->GetString("profileName", &event_profile));
+  ASSERT_EQ(profile1_name, event_profile);
+
+  ASSERT_TRUE(events[1]->data()->GetString("profileName", &event_profile));
+  ASSERT_EQ(profile2_name, event_profile);
+}
+
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, KilledByOSEvent) {
   ui_test_utils::CrashTab(chrome::GetActiveWebContents(browser()));
 
   std::vector<linked_ptr<Event> > events = GetEvents();
 
   ASSERT_EQ(1u, events.size());
   CheckEvent(EVENT_KILLED_BY_OS_CRASH, events[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, RendererCrashEvent) {
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUICrashURL));
 
   std::vector<linked_ptr<Event> > events = GetEvents();
   ASSERT_EQ(1u, events.size());
 
   CheckEvent(EVENT_RENDERER_CRASH, events[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, NewVersionEvent) {
   const char kOldVersion[] = "0.0";
 
-  content::BrowserThread::PostBlockingPoolSequencedTask(
-      Database::kDatabaseSequenceToken,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&Database::AddStateValue),
-                 base::Unretained(performance_monitor()->database()),
-                 std::string(kStateChromeVersion),
-                 std::string(kOldVersion)));
-
-  content::BrowserThread::GetBlockingPool()->FlushForTesting();
+  AddStateValue(kStateChromeVersion, kOldVersion);
 
   performance_monitor()->CheckForVersionUpdate();
 
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
 
   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;
   ASSERT_TRUE(events[0]->data()->GetAsDictionary(&value));
 
   std::string previous_version;
   std::string current_version;
 
   ASSERT_TRUE(value->GetString("previousVersion", &previous_version));
   ASSERT_EQ(kOldVersion, previous_version);
   ASSERT_TRUE(value->GetString("currentVersion", &current_version));
   ASSERT_EQ(version_string, current_version);
 }
 
 }  // namespace performance_monitor