Write "logout-started" event on next boot.

chrome/browser/chromeos/boot_times_loader.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/chromeos/boot_times_loader.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
+#include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/auth/authentication_notification_details.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::RenderWidgetHost;
 using content::RenderWidgetHostView;
 using content::WebContents;
 
 namespace {
 
+const char kStatsDividerCharacter = '^';
+
 RenderWidgetHost* GetRenderWidgetHost(NavigationController* tab) {
   WebContents* web_contents = tab->GetWebContents();
   if (web_contents) {
     RenderWidgetHostView* render_widget_host_view =
         web_contents->GetRenderWidgetHostView();
     if (render_widget_host_view)
       return render_widget_host_view->GetRenderWidgetHost();
   }
   return NULL;
 }
@@ skipping 202 matching lines @@
   // has already been terminated.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          !BrowserThread::IsMessageLoopValid(BrowserThread::UI));
 
   WriteTimes(kLogoutTimes,
              (restart_requested_ ? kUmaRestart : kUmaLogout),
              kUmaLogoutPrefix,
              logout_time_markers_);
 }
 
+// static
+void BootTimesLoader::ClearLogoutStartedLastPreference() {
+  PrefService* local_state = g_browser_process->local_state();
+  local_state->ClearPref(prefs::kLogoutStartedLast);
+}
+
+void BootTimesLoader::OnBoot() {
+  PrefService* local_state = g_browser_process->local_state();
+  const std::string logout_started_last_str =
+      local_state->GetString(prefs::kLogoutStartedLast);
+  if (logout_started_last_str.empty())
+    return;
+
+  // Note that kLogoutStartedLast is not cleared on format error to stay in
+  // logs in case of other fatal system errors.
+
+  const Stats logout_started_last_stats =
+      Stats::DeserializeFromString(logout_started_last_str);
+  if (logout_started_last_stats.uptime.empty())
+    return;
+
+  // Extract double uptime seconds.
+  const std::string logout_started_last_uptime_str =
+      GetUptimeSeconds(logout_started_last_stats);
+  if (logout_started_last_uptime_str.empty())
+    return;
+
+  const std::string uptime_str = GetUptimeSeconds(GetCurrentStats());
+
+  double logout_started_last;
+  double uptime;
+  if (!base::StringToDouble(logout_started_last_uptime_str,
+                            &logout_started_last) ||
+      !base::StringToDouble(uptime_str, &uptime)) {
+    return;
+  }
+
+  if (logout_started_last >= uptime) {
+    // Reboot happened.
+    ClearLogoutStartedLastPreference();
+    return;
+  }
+  // Write /tmp/uptime-logout-started as well.
+  const char kLogoutStarted[] = "logout-started";
+  RecordStatsWithCallback(
+      kLogoutStarted,
+      logout_started_last_stats,
+      base::Bind(&BootTimesLoader::ClearLogoutStartedLastPreference));
+}
+
+void BootTimesLoader::OnLogoutStarted(PrefService* state) {
+  const std::string uptime = GetCurrentStats().SerializeToString();
+  if (!uptime.empty())
+    state->SetString(prefs::kLogoutStartedLast, uptime);
+}
+
 void BootTimesLoader::RecordStats(const std::string& name, const Stats& stats) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&RecordStatsDelayed, name, stats.uptime, stats.disk));
 }
 
+void BootTimesLoader::RecordStatsWithCallback(const std::string& name,
+                                              const Stats& stats,
+                                              const base::Closure& callback) {
+  BrowserThread::PostBlockingPoolTaskAndReply(
+      FROM_HERE,
+      base::Bind(&RecordStatsDelayed, name, stats.uptime, stats.disk),
+      callback);
+}
+
+std::string BootTimesLoader::Stats::SerializeToString() const {
+  if (uptime.empty() || disk.empty())
+    return std::string();
+
+  return uptime + kStatsDividerCharacter + disk;
+}
+
+// static
+BootTimesLoader::Stats BootTimesLoader::Stats::DeserializeFromString(
+    const std::string& value) {
+  Stats result;
+
+  const size_t divider_at = value.find_first_of(kStatsDividerCharacter);
+  if (divider_at != std::string::npos) {
+    result.uptime = value.substr(0, divider_at);
+    result.disk = value.substr(divider_at + 1);
+  }

[stevenjb, 2014/05/30 16:20:23]

While on the one hand this is fairly trivial, if we ever expand Stats it will be
a pain to maintain. Maybe consider using DictionaryValue and [de]serializing
that as a JSON string.

[Alexander Alekseev, 2014/05/30 21:12:45]

Done.

+  return result;
+}
+
 BootTimesLoader::Stats BootTimesLoader::GetCurrentStats() {
   const base::FilePath kProcUptime(FPL("/proc/uptime"));
   const base::FilePath kDiskStat(FPL("/sys/block/sda/stat"));
   Stats stats;
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   base::ReadFileToString(kProcUptime, &stats.uptime);
   base::ReadFileToString(kDiskStat, &stats.disk);
   return stats;
 }
 
+std::string BootTimesLoader::GetUptimeSeconds(
+    const BootTimesLoader::Stats& stats) {
+  std::string uptime = stats.uptime;
+  const size_t space_at = uptime.find_first_of(' ');

[stevenjb, 2014/05/30 16:20:23]

Where is this ' ' coming from?

[Alexander Alekseev, 2014/05/30 21:12:45]

/proc/uptime has two fields: uptime in seconds and cumulative idle time in
seconds. So here the first field is extracted.

+  if (space_at == std::string::npos)
+    return std::string();
+
+  uptime.resize(space_at);
+  return uptime;
+}

[stevenjb, 2014/05/30 16:20:23]

This seems like either it should be a member of Stats (which should really be a
class now, and could be forward declared in the header and defined in the .cc
file). Or if we make Stats a DictionaryValue, this + [De]Serialize should just
be local helper methods.

[Alexander Alekseev, 2014/05/30 21:12:45]

There is a member of type Stats, so I decided to leave declaration in header.
The rest is done.

+
 void BootTimesLoader::RecordCurrentStats(const std::string& name) {
   RecordStats(name, GetCurrentStats());
 }
 
 void BootTimesLoader::SaveChromeMainStats() {
   chrome_main_stats_ = GetCurrentStats();
 }
 
 void BootTimesLoader::RecordChromeMainStats() {
   RecordStats(kChromeMain, chrome_main_stats_);
@@ skipping 104 matching lines @@
           GetRenderWidgetHost(&web_contents->GetController());
       render_widget_hosts_loading_.erase(render_widget_host);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace chromeos