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(kStateProfilePrefix + profile_name, time);
+
+  performance_monitor()->CheckForUncleanExits();
+
+  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) {
+  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(kStateProfilePrefix + profile1_name, time1);
+  AddStateValue(kStateProfilePrefix + profile2_name, time2);
+
+  performance_monitor()->CheckForUncleanExits();
+  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]);
 }
 
 // Test is flaky on Windows, see http://crbug.com/135635
 #if defined(OS_WIN)
 #define MAYBE_NewVersionEvent DISABLED_NewVersionEvent
 #else
 #define MAYBE_NewVersionEvent NewVersionEvent
 #endif
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, MAYBE_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