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"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/values.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_screenlock_state_handler.h"
 #include "chrome/browser/signin/easy_unlock_service_factory.h"
 #include "chrome/browser/signin/easy_unlock_service_observer.h"
 #include "chrome/browser/signin/easy_unlock_toggle_flow.h"
 #include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/common/chrome_switches.h"
 #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_registry.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_->DisableApp();
+    service_->screenlock_state_handler_.reset();
+  }
+
+  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 193 matching lines @@
   // Only allow app path override switch for debug build.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEasyUnlockAppPath)) {
     easy_unlock_path =
         command_line->GetSwitchValuePath(switches::kEasyUnlockAppPath);
   }
 #endif  // !defined(NDEBUG)
 
   if (!easy_unlock_path.empty()) {
     extensions::ComponentLoader* loader = GetComponentLoader(profile_);
-    if (!loader->Exists(extension_misc::kEasyUnlockAppId))
+    if (!loader->Exists(extension_misc::kEasyUnlockAppId)) {
       loader->Add(IDR_EASY_UNLOCK_MANIFEST, easy_unlock_path);
+    } else {

[tbarzic, 2014/09/10 19:56:46]

We probably want to ensure that the extension is enabled even when it's loaded.
(consider the case where the device shuts down during sleep; the app will remain
disabled even when it's loaded on the next boot)

[Tim Song, 2014/09/11 03:00:05]

Can this scenario even happen? It doesn't seem like component_loader stores
extensions that were previously added, so we will re-add this extension when the
system reboots.

[tbarzic, 2014/09/11 03:16:42]

Afaik, this may happen e.g. if chrome crashes when waking up, or battery runs
out while sleeping.
We will re-add the extension, but it will be disabled (the state is saved in
profile prefs, so it persists across sessions).

+      extensions::ExtensionRegistry* registry =
+          extensions::ExtensionRegistry::Get(profile_);
+
+      // If the app is installed but disabled, then enable it.
+      if (registry->GetExtensionById(extension_misc::kEasyUnlockAppId,

[tbarzic, 2014/09/10 19:56:46]

you can probably skip this if; EnableExtension handles the case when the
extension is already enabled.

same for DisableExtension bellow

[Tim Song, 2014/09/11 03:00:05]

Good point. I'll fix it in https://codereview.chromium.org/535343003/.

+                                     extensions::ExtensionRegistry::DISABLED)) {
+        ExtensionService* extension_service =
+            extensions::ExtensionSystem::Get(profile_)->extension_service();
+        extension_service->EnableExtension(extension_misc::kEasyUnlockAppId);
+      }
+    }
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
-void EasyUnlockService::UnloadApp() {
+void EasyUnlockService::DisableApp() {
   extensions::ComponentLoader* loader = GetComponentLoader(profile_);
-  if (loader->Exists(extension_misc::kEasyUnlockAppId))
-    loader->Remove(extension_misc::kEasyUnlockAppId);
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(profile_);
+
+  if (loader->Exists(extension_misc::kEasyUnlockAppId) &&
+      registry->GetExtensionById(extension_misc::kEasyUnlockAppId,
+                                 extensions::ExtensionRegistry::ENABLED)) {
+    ExtensionService* extension_service =
+        extensions::ExtensionSystem::Get(profile_)->extension_service();
+    extension_service->DisableExtension(extension_misc::kEasyUnlockAppId,
+                                        extensions::Extension::DISABLE_RELOAD);
+  }
 }
 
 void EasyUnlockService::UpdateAppState() {
   if (IsAllowed()) {
     LoadApp();
+
+#if defined(OS_CHROMEOS)
+  if (!power_monitor_)
+    power_monitor_.reset(new PowerMonitor(this));
+#endif
   } else {
-    UnloadApp();
+    DisableApp();
     // 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);
   }
 }