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"
@@ skipping 138 matching lines @@
   }
 
   virtual ~PowerMonitor() {
     chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
         RemoveObserver(this);
   }
 
  private:
   // chromeos::PowerManagerClient::Observer:
   virtual void SuspendImminent() override {
-    service_->DisableAppIfLoaded();
+    service_->DisableAppIfLoaded(false /* don't reset screenlock state */);
+    service_->GetScreenlockStateHandler()->ChangeState(
+        EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING);
   }
 
   virtual void SuspendDone(const base::TimeDelta& sleep_duration) override {
-    service_->LoadApp();
+    service_->UpdateAppState();
+    // Note that |this| may get deleted after |UpdateAppState| is called.
   }
 
   EasyUnlockService* service_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
 };
 #endif
 
 EasyUnlockService::EasyUnlockService(Profile* profile)
     : profile_(profile),
@@ skipping 48 matching lines @@
 }
 
 bool EasyUnlockService::IsAllowed() {
   if (shut_down_)
     return false;
 
   if (!IsAllowedInternal())
     return false;
 
 #if defined(OS_CHROMEOS)
-  if (!bluetooth_detector_->IsPresent())
+  if (bluetooth_detector_.get() && !bluetooth_detector_->IsPresent()) {

[Tim Song, 2014/10/10 06:46:14]

Comment that bluetooth_detector_ is NULL if we successfully found an adapter
already, or add a new variable to track this state.

     return false;
+  }
 
   return true;
 #else
   // TODO(xiyuan): Revisit when non-chromeos platforms are supported.
   return false;
 #endif
 }
 
 void EasyUnlockService::SetHardlockState(
     EasyUnlockScreenlockStateHandler::HardlockState state) {
@@ skipping 168 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();
+void EasyUnlockService::DisableAppIfLoaded(bool reset_screenlock_state) {
+  if (reset_screenlock_state)
+    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 10 matching lines @@
     return;
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile_);
   extension_system->extension_service()->ReloadExtension(
       extension_misc::kEasyUnlockAppId);
   NotifyUserUpdated();
 }
 
 void EasyUnlockService::UpdateAppState() {
   if (IsAllowed()) {
+    // Bluetooth detector is used to make sure Easy Unlock is not enabled on
+    // devices that do not support Bluetooth. If Easy Unlock is allowed, that
+    // means that the bluetooth is supported on the device, so bluetooth
+    // detector is not needed any more (and might actually prolong time needed
+    // for the app to get reloaded after suspend).
+    bluetooth_detector_.reset();

[tbarzic, 2014/10/10 01:12:54]

Let me know if you don't like this and I'll try to find a better solution.
The problem is that bluetooth_detector_->IsPresent returns false immediately
after suspend is done. This would cause DisableAppIfLoaded to be called, and
easy-unlock icon to be removed from the screenlock UI.

[Tim Song, 2014/10/10 06:46:14]

I'm fine with this, and improving the start-up time is always a good thing.

I would put this reset() down in OnBluetoothAdapterPresentChanged(), so the
intent is more clear.

[xiyuan, 2014/10/10 15:45:53]

The detector is kept around to support devices that uses usb bluetooth dongle
such as lumpy. The presence of BT could change dynamically.

Maybe we should ignore the OnBluetoothAdapterPresentChanged on suspending.

[tbarzic, 2014/10/10 17:59:43]

Yeah, I though there may be a reason for keeping detector around I was missing.
Alternative approach I was thinking about was something in line with your
suggestion (though, we get OnSuspendDone before the adaptor gets reinitialized,
so we may want to ignore the detector state for some time after waking up).. let
me think about it a bit more.

+
     LoadApp();
 
 #if defined(OS_CHROMEOS)
   if (!power_monitor_)
     power_monitor_.reset(new PowerMonitor(this));
 #endif
   } else {
-    DisableAppIfLoaded();
+    DisableAppIfLoaded(true /* reset screenlock state */);
 #if defined(OS_CHROMEOS)
     power_monitor_.reset();
 #endif
   }
 }
 
 void EasyUnlockService::NotifyUserUpdated() {
   std::string user_id = GetUserEmail();
   if (user_id.empty())
     return;
@@ skipping 85 matching lines @@
   for (const auto& device_key_data : key_data_list)
     devices_in_cryptohome.insert(device_key_data.public_key);
 
   if (paired_devices != devices_in_cryptohome) {
     SetHardlockStateForUser(user_id,
                             EasyUnlockScreenlockStateHandler::PAIRING_CHANGED);
   }
 }
 #endif