Reimplement EasyUnlock.StartupTimeFromSuspend metric.

chrome/browser/signin/easy_unlock_service.cc

 // Copyright 2014 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/signin/easy_unlock_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 120 matching lines @@
         weak_ptr_factory_(this) {
     chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
         AddObserver(this);
   }
 
   virtual ~PowerMonitor() {
     chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
         RemoveObserver(this);
   }
 
+  // Called when the remote device has been authenticated to record the time
+  // delta from waking up. No time will be recorded if the start-up time has
+  // already been recorded or if the system never went to sleep previously.
+  void RecordStartUpTime() {
+    if (wake_up_time_.is_null())
+      return;
+    UMA_HISTOGRAM_MEDIUM_TIMES(
+        "EasyUnlock.StartupTimeFromSuspend",
+        base::Time::Now() - wake_up_time_);
+    wake_up_time_ = base::Time();
+  }
+
   bool waking_up() const { return waking_up_; }
 
  private:
   // chromeos::PowerManagerClient::Observer:
   virtual void SuspendImminent() override {
     service_->PrepareForSuspend();
   }
 
   virtual void SuspendDone(const base::TimeDelta& sleep_duration) override {
     waking_up_ = true;
+    wake_up_time_ = base::Time::Now();
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PowerMonitor::ResetWakingUp,
                    weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(5));
     service_->UpdateAppState();
     // Note that |this| may get deleted after |UpdateAppState| is called.
   }
 
   void ResetWakingUp() {
     waking_up_ = false;
     service_->UpdateAppState();
   }
 
   EasyUnlockService* service_;
   bool waking_up_;
+  base::Time wake_up_time_;
   base::WeakPtrFactory<PowerMonitor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
 };
 #endif
 
 EasyUnlockService::EasyUnlockService(Profile* profile)
     : profile_(profile),
       bluetooth_detector_(new BluetoothDetector(this)),
       shut_down_(false),
@@ skipping 140 matching lines @@
 }
 
 bool EasyUnlockService::UpdateScreenlockState(
     EasyUnlockScreenlockStateHandler::State state) {
   EasyUnlockScreenlockStateHandler* handler = GetScreenlockStateHandler();
   if (!handler)
     return false;
 
   handler->ChangeState(state);
 
-  if (state != EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED &&
-      auth_attempt_.get()) {
+  if (state == EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED) {
+#if defined(OS_CHROMEOS)
+    if (power_monitor_)
+      power_monitor_->RecordStartUpTime();
+#endif
+  } else if (auth_attempt_.get()) {
+    // Clean up existing auth attempt if we can no longer authenticate the
+    // remote device.
     auth_attempt_.reset();
 
     if (!handler->InStateValidOnRemoteAuthFailure())
       HandleAuthFailure(GetUserEmail());
   }
   return true;
 }
 
 void EasyUnlockService::AttemptAuth(const std::string& user_id) {
   auth_attempt_.reset(new EasyUnlockAuthAttempt(
@@ skipping 315 matching lines @@
 }
 #endif
 
 void EasyUnlockService::PrepareForSuspend() {
   DisableAppIfLoaded();
   if (screenlock_state_handler_ && screenlock_state_handler_->IsActive()) {
     UpdateScreenlockState(
         EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
   }
 }