Easy Unlock Show connecting user pod icon when waking up from sleep

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/field_trial.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"
 #include "chrome/browser/signin/easy_unlock_auth_attempt.h"
 #include "chrome/browser/signin/easy_unlock_service_factory.h"
 #include "chrome/browser/signin/easy_unlock_service_observer.h"
 #include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 112 matching lines @@
   scoped_refptr<device::BluetoothAdapter> adapter_;
   base::WeakPtrFactory<BluetoothDetector> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDetector);
 };
 
 #if defined(OS_CHROMEOS)
 class EasyUnlockService::PowerMonitor
     : public chromeos::PowerManagerClient::Observer {
  public:
-  explicit PowerMonitor(EasyUnlockService* service) : service_(service) {
+  explicit PowerMonitor(EasyUnlockService* service)
+      : service_(service),
+        waking_up_(false),
+        weak_ptr_factory_(this) {
     chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
         AddObserver(this);
   }
 
   virtual ~PowerMonitor() {
     chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
         RemoveObserver(this);
   }
 
+  bool waking_up() const { return waking_up_; }
+
  private:
   // chromeos::PowerManagerClient::Observer:
   virtual void SuspendImminent() override {
-    service_->DisableAppIfLoaded();
+    service_->PrepareForSuspend();
   }
 
   virtual void SuspendDone(const base::TimeDelta& sleep_duration) override {
-    service_->LoadApp();
+    waking_up_ = true;
+    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::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),
       weak_ptr_factory_(this) {
@@ skipping 239 matching lines @@
     ExtensionService* extension_service =
         extensions::ExtensionSystem::Get(profile_)->extension_service();
     extension_service->EnableExtension(extension_misc::kEasyUnlockAppId);
 
     NotifyUserUpdated();
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
 void EasyUnlockService::DisableAppIfLoaded() {
-  // Make sure lock screen state set by the extension gets reset.
-  ResetScreenlockState();
-
   extensions::ComponentLoader* loader = GetComponentLoader(profile_);
   if (!loader->Exists(extension_misc::kEasyUnlockAppId))
     return;
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   extension_service->DisableExtension(extension_misc::kEasyUnlockAppId,
                                       extensions::Extension::DISABLE_RELOAD);
 }
 
@@ skipping 12 matching lines @@
   extension_system->extension_service()->ReloadExtension(
       extension_misc::kEasyUnlockAppId);
   NotifyUserUpdated();
 }
 
 void EasyUnlockService::UpdateAppState() {
   if (IsAllowed()) {
     LoadApp();
 
 #if defined(OS_CHROMEOS)
-  if (!power_monitor_)
-    power_monitor_.reset(new PowerMonitor(this));
+    if (!power_monitor_)
+      power_monitor_.reset(new PowerMonitor(this));
 #endif
   } else {
-    DisableAppIfLoaded();
+    bool bluetooth_waking_up = false;
 #if defined(OS_CHROMEOS)
-    power_monitor_.reset();
+    // If the service is not allowed due to bluetooth not being detected just
+    // after system suspend is done, give bluetooth more time to be detected
+    // before disabling the app (and resetting screenlock state).
+    bluetooth_waking_up =
+        power_monitor_.get() && power_monitor_->waking_up() &&
+        !bluetooth_detector_->IsPresent();
 #endif
+
+    if (!bluetooth_waking_up) {
+      DisableAppIfLoaded();
+      ResetScreenlockState();
+#if defined(OS_CHROMEOS)
+      power_monitor_.reset();
+#endif
+    }
   }
 }
 
 void EasyUnlockService::NotifyUserUpdated() {
   std::string user_id = GetUserEmail();
   if (user_id.empty())
     return;
 
   // Notify the easy unlock app that the user info changed.
   extensions::api::easy_unlock_private::UserInfo info;
@@ skipping 83 matching lines @@
     devices_in_cryptohome.insert(device_key_data.public_key);
 
   if (paired_devices != devices_in_cryptohome ||
       GetHardlockState() == EasyUnlockScreenlockStateHandler::NO_PAIRING) {
     SetHardlockStateForUser(user_id,
                             EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
   }
 }
 #endif
 
+void EasyUnlockService::PrepareForSuspend() {
+  DisableAppIfLoaded();
+  if (screenlock_state_handler_ && screenlock_state_handler_->IsActive()) {
+    UpdateScreenlockState(
+        EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
+  }
+}
+