Add Unclean Exit Watching to CPM

chrome/browser/performance_monitor/performance_monitor.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/performance_monitor/performance_monitor.h"
 
+#include <set>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/process_util.h"
+#include "base/string_number_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/performance_monitor_util.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_list.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 
 using extensions::Extension;
 
+namespace {
+
+bool TimeToString(base::Time time, std::string* output) {

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

It doesn't make sense that conversion in this direction could fail. This should
just return a string.

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

Done.

+  int64 time_int64 = time.ToInternalValue();
+  *output = base::Int64ToString(time_int64);
+  return !output->empty();
+}
+
+bool StringToTime(std::string time, base::Time* output) {
+  int64 time_int64 = 0;
+  if (!base::StringToInt64(time, &time_int64))
+    return false;
+  *output = base::Time::FromInternalValue(time_int64);
+  return true;
+}
+
+}  // namespace
+
 namespace performance_monitor {
 
 PerformanceMonitor::PerformanceMonitor() : database_(NULL) {
 }
 
 PerformanceMonitor::~PerformanceMonitor() {
 }
 
 void PerformanceMonitor::Start() {
+  std::string time;
+  CHECK(TimeToString(base::Time::Now(), &time));
   content::BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&PerformanceMonitor::InitOnBackgroundThread,
                  base::Unretained(this)),
       base::Bind(&PerformanceMonitor::FinishInit,
                  base::Unretained(this)));
 }
 
 void PerformanceMonitor::InitOnBackgroundThread() {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   database_ = Database::Create(database_path_);
 }
 
 bool PerformanceMonitor::SetDatabasePath(const FilePath& path) {
   if (!database_.get()) {
     database_path_ = path;
     return true;
   }
 
   // PerformanceMonitor already initialized with another path.
   return false;
 }
 
 void PerformanceMonitor::FinishInit() {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   RegisterForNotifications();
+  CheckForUncleanExit();
   CheckForVersionUpdate();
+
+  timer_.Start(FROM_HERE, base::TimeDelta::FromMinutes(2),
+               this, &PerformanceMonitor::DoTimedCollections);
 }
 
 void PerformanceMonitor::RegisterForNotifications() {
   // Extensions
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
 
   // Crashes
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_HANG,
       content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
       content::NotificationService::AllSources());
+
+  // Profiles (for unclean exit)
+  registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
+      content::NotificationService::AllSources());
 }
 
 // Static
 PerformanceMonitor* PerformanceMonitor::GetInstance() {
   return Singleton<PerformanceMonitor>::get();
 }
 
 void PerformanceMonitor::AddEvent(scoped_ptr<Event> event) {
   content::BrowserThread::PostBlockingPoolSequencedTask(
       Database::kDatabaseSequenceToken,
@@ skipping 54 matching lines @@
                    current_version));
     if (!previous_version.empty()) {
       AddEvent(util::CreateChromeUpdateEvent(
           base::Time::Now(),
           previous_version,
           current_version));
     }
   }
 }
 
+// The reason we need this as well as a notification check is because the first
+// profiles can be loaded prior to the initialization of PerformanceMonitor. In
+// this case, we find if they exited uncleanly here.

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

This comment is written backwards. I'd say
"At init time, we find if profiles exited uncleanly in the case that they were
first loaded prior to the init..."

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

Done.

+void PerformanceMonitor::CheckForUncleanExit() {

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

CheckForUncleanExits

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

Done.

+  std::vector<Profile*> profiles =
+      g_browser_process->profile_manager()->GetLoadedProfiles();
+
+  for (std::vector<Profile*>::const_iterator iter = profiles.begin();
+       iter != profiles.end(); ++iter) {
+    if (!(*iter)->DidLastSessionExitCleanly()) {
+      content::BrowserThread::PostBlockingPoolSequencedTask(
+          Database::kDatabaseSequenceToken,
+          FROM_HERE,
+          base::Bind(&PerformanceMonitor::AddUncleanExitEvent,
+                     base::Unretained(this),
+                     (*iter)->GetDebugName()));
+    }
+  }
+}
+
+void PerformanceMonitor::AddUncleanExitEvent(std::string profile_name) {
+  std::string database_key = kStateProfile + profile_name;
+  std::string last_active_string = database_->GetStateValue(database_key);
+
+  // Check if there was no previous time; this should only happen if the profile
+  // was last used prior to PerformanceMonitor's integration. Do nothing in this
+  // case, since the event was prior to the beginning of our recording.
+  if (last_active_string.empty())
+    return;
+
+  base::Time last_active_time;
+  CHECK(StringToTime(last_active_string, &last_active_time));
+
+  // We should never find a case where the last active time for the profile is
+  // after the current time. DCHECK (instead of CHECK) because of the chance
+  // that someone has backdated the system time, so that Chrome won't crash in

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

This seems like a case that could actually happen, more than one might think. It
seems safe to proceed anyway though.

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

Yeah, I wasn't sure about this one...it won't break anything to continue on
(hence the DCHECK, not CHECK), but it's not necessarily good, either. In
retrospect, though, if someone's messing with the system time and using chrome,
it's quite possible they *are* debugging, so this would get very annoying very
quickly. Removed it.

+  // a release build.
+  DCHECK(last_active_time < base::Time::Now());
+
+  scoped_ptr<Event> event =
+      util::CreateUncleanExitEvent(last_active_time, profile_name);
+
+  database_->AddEvent(*event.get());
+}
+
+void PerformanceMonitor::UpdateLiveProfiles() {
+  std::string time;
+  CHECK(TimeToString(base::Time::Now(), &time));
+  scoped_ptr<std::set<std::string> > active_profiles(
+      new std::set<std::string>());
+
+  for (BrowserList::const_iterator iter = BrowserList::begin();
+       iter != BrowserList::end(); ++iter) {
+    active_profiles->insert((*iter)->profile()->GetDebugName());
+  }
+
+  content::BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::UpdateLiveProfilesHelper,
+                 base::Unretained(this),
+                 base::Passed(active_profiles.Pass()),
+                 time));
+}
+
+void PerformanceMonitor::UpdateLiveProfilesHelper(
+    scoped_ptr<std::set<std::string> > active_profiles,
+    std::string time) {
+  CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  for (std::set<std::string>::const_iterator iter = active_profiles->begin();
+       iter != active_profiles->end(); ++iter) {
+    database_->AddStateValue(kStateProfile + *iter, time);
+  }
+}
+
+void PerformanceMonitor::DoTimedCollections() {
+  UpdateLiveProfiles();
+}
+
 void PerformanceMonitor::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       const Extension* extension = content::Details<Extension>(details).ptr();
       AddEvent(util::CreateExtensionInstallEvent(base::Time::Now(),
                                                  extension->id(),
                                                  extension->name(),
                                                  extension->url().spec(),
@@ skipping 66 matching lines @@
       // Determine the type of crash.
       EventType type =
           status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ?
           EVENT_KILLED_BY_OS_CRASH : EVENT_RENDERER_CRASH;
 
       AddEvent(util::CreateCrashEvent(base::Time::Now(),
                                       type,
                                       contents->GetURL().spec()));
       break;
     }
+    case chrome::NOTIFICATION_PROFILE_ADDED: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      if (!profile->DidLastSessionExitCleanly()) {
+        content::BrowserThread::PostBlockingPoolSequencedTask(
+            Database::kDatabaseSequenceToken,
+            FROM_HERE,
+            base::Bind(&PerformanceMonitor::AddUncleanExitEvent,
+                       base::Unretained(this),
+                       profile->GetDebugName()));
+      }
+      break;
+    }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 }  // namespace performance_monitor