Unload Easy Unlock app when ChromeOS suspends and reload on wake up.

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/memory/ref_counted.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/one_shot_event.h"
 #include "grit/browser_resources.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager_client.h"
 #include "components/user_manager/user_manager.h"
 #endif
 
 namespace {
 
 // Key name of the local device permit record dictonary in kEasyUnlockPairing.
 const char kKeyPermitAccess[] = "permitAccess";
 
 // Key name of the remote device list in kEasyUnlockPairing.
 const char kKeyDevices[] = "devices";
@@ skipping 54 matching lines @@
   }
 
   // Owner of this class and should out-live this class.
   EasyUnlockService* service_;
   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) {
+    chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
+        AddObserver(this);
+  }
+
+  virtual ~PowerMonitor() {
+    chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
+        RemoveObserver(this);
+  }
+
+ private:
+  // chromeos::PowerManagerClient::Observer:
+  virtual void SuspendImminent() OVERRIDE {
+    service_->UnloadApp();

[tbarzic, 2014/09/03 21:40:37]

you could add screenlock_state_handler_.reset() to UnloadApp instead of
resetting the screenlock_state_handler here.

[Tim Song, 2014/09/03 21:53:39]

Done.

+    EasyUnlockScreenlockStateHandler* screenlock_state_handler =
+        service_->GetScreenlockStateHandler();
+    if (screenlock_state_handler) {
+      screenlock_state_handler->ChangeState(
+          EasyUnlockScreenlockStateHandler::STATE_INACTIVE);
+    }
+  }
+
+  virtual void SuspendDone(const base::TimeDelta& sleep_duration) OVERRIDE {
+    service_->LoadApp();
+  }
+
+  EasyUnlockService* service_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
+};
+#endif
+
 EasyUnlockService::EasyUnlockService(Profile* profile)
     : profile_(profile),
       bluetooth_detector_(new BluetoothDetector(this)),
       turn_off_flow_status_(IDLE),
       weak_ptr_factory_(this) {
   extensions::ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
       base::Bind(&EasyUnlockService::Initialize,
                  weak_ptr_factory_.GetWeakPtr()));
 }
@@ skipping 208 matching lines @@
 
 void EasyUnlockService::UnloadApp() {
   extensions::ComponentLoader* loader = GetComponentLoader(profile_);
   if (loader->Exists(extension_misc::kEasyUnlockAppId))
     loader->Remove(extension_misc::kEasyUnlockAppId);
 }
 
 void EasyUnlockService::UpdateAppState() {
   if (IsAllowed()) {
     LoadApp();
+
+#if defined(OS_CHROMEOS)
+  if (!power_monitor_)
+    power_monitor_.reset(new PowerMonitor(this));
+#endif
   } else {
     UnloadApp();
     // Reset the screenlock state handler to make sure Screenlock state set
     // by Easy Unlock app is reset.
     screenlock_state_handler_.reset();
+
+#if defined(OS_CHROMEOS)
+    power_monitor_.reset();
+#endif
   }
 }
 
 void EasyUnlockService::OnPrefsChanged() {
   UpdateAppState();
 }
 
 void EasyUnlockService::OnBluetoothAdapterPresentChanged() {
   UpdateAppState();
 }
@@ skipping 18 matching lines @@
   // Make sure lock screen state set by the extension gets reset.
   screenlock_state_handler_.reset();
 
   if (GetComponentLoader(profile_)->Exists(extension_misc::kEasyUnlockAppId)) {
     extensions::ExtensionSystem* extension_system =
         extensions::ExtensionSystem::Get(profile_);
     extension_system->extension_service()->ReloadExtension(
         extension_misc::kEasyUnlockAppId);
   }
 }