No Easy unlock if bluetooth is not available.

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/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_service_factory.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_system.h"
 #include "extensions/common/one_shot_event.h"
 #include "grit/browser_resources.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #endif
 
 namespace {
 
 extensions::ComponentLoader* GetComponentLoader(
     content::BrowserContext* context) {
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(context);
   ExtensionService* extension_service = extension_system->extension_service();
   return extension_service->component_loader();
 }
 
 }  // namespace
 
 // static
 EasyUnlockService* EasyUnlockService::Get(Profile* profile) {
   return EasyUnlockServiceFactory::GetForProfile(profile);
 }
 
+class EasyUnlockService::BluetoothDetector
+    : public device::BluetoothAdapter::Observer {
+ public:
+  explicit BluetoothDetector(EasyUnlockService* service)
+      : service_(service), weak_ptr_factory_(this) {}

[Ilya Sherman, 2014/08/14 07:29:41]

nit: One per line, please.

[xiyuan, 2014/08/14 20:27:43]

Done. I personally like one-per-line style but "git cl format" thinks other way.

+
+  virtual ~BluetoothDetector() {
+    if (adapter_)
+      adapter_->RemoveObserver(this);
+  }
+
+  void Initialize() {
+    if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable())
+      return;
+
+    device::BluetoothAdapterFactory::GetAdapter(
+        base::Bind(&BluetoothDetector::OnAdapterInitialized,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  bool IsPresent() const {
+    return adapter_ && adapter_->IsPresent();
+  }
+
+  // device::BluetoothAdapter::Observer
+  virtual void AdapterPresentChanged(device::BluetoothAdapter* adapter,
+                                     bool present) OVERRIDE {
+    ReportAdapterPresent();

[Ilya Sherman, 2014/08/14 07:29:41]

If the adapter was removed from the system, should |adapter_| be reset?  Is it
possible that a *different* adapter will be added to the system?  (It seems like
it ought to be possible, e.g. if I plug in an adapter via USB.)

[xiyuan, 2014/08/14 20:27:43]

Nope. The BluetoothAdapter instance never changes after it gets created. If the
adapter is no longer available, the state of BluetoothAdapter is changed. The
same instance is still kept around. The state is updated when an adapter is
available again. At least, that is the case with cros and win.

armansito@, can you confirm?

[armansito, 2014/08/14 20:55:05]

Yep, exactly. We have a singleton BluetoothAdapter at all times which represents
whatever Bluetooth adapter on the system is deemed to be currently active. So if
you had a USB adapter and unplugged it, the BluetoothAdapter would still exist
and send an AdapterPresentChanged event to its observers.

+  }
+
+ private:
+  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {
+    adapter_ = adapter;
+    adapter_->AddObserver(this);
+    ReportAdapterPresent();
+  }
+
+  void ReportAdapterPresent() {
+    service_->OnBluetoothAdapterPresentChanged();
+  }
+
+  EasyUnlockService* service_;

[Ilya Sherman, 2014/08/14 07:29:41]

nit: Please document lifetime expectations.

[xiyuan, 2014/08/14 20:27:43]

Done.

+  scoped_refptr<device::BluetoothAdapter> adapter_;
+  base::WeakPtrFactory<BluetoothDetector> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(BluetoothDetector);
+};
+
 EasyUnlockService::EasyUnlockService(Profile* profile)
-    : profile_(profile), weak_ptr_factory_(this) {
+    : profile_(profile),
+      bluetooth_detector_(new BluetoothDetector(this)),
+      weak_ptr_factory_(this) {
   extensions::ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
       base::Bind(&EasyUnlockService::Initialize,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 EasyUnlockService::~EasyUnlockService() {
 }
 
 // static
@@ skipping 31 matching lines @@
 #if defined(OS_CHROMEOS)
   if (chromeos::UserManager::Get()->IsLoggedInAsGuest())
     return false;
 
   if (!chromeos::ProfileHelper::IsPrimaryProfile(profile_))
     return false;
 
   if (!profile_->GetPrefs()->GetBoolean(prefs::kEasyUnlockAllowed))
     return false;
 
   // It is only disabled when the trial exists and is in "Disable" group.

[Ilya Sherman, 2014/08/14 07:29:41]

nit: Please update this comment.

[xiyuan, 2014/08/14 20:27:43]

Removed "only".

-  return base::FieldTrialList::FindFullName("EasyUnlock") != "Disable";
+  if (base::FieldTrialList::FindFullName("EasyUnlock") == "Disable")
+    return false;
+
+  if (!bluetooth_detector_->IsPresent())
+    return false;
+
+  return true;

[Ilya Sherman, 2014/08/14 07:29:41]

Hmm, do we not have any command-line switches associated with the feature
anymore?  Typically, the best practice for code that is controlled by a Finch
trial is to also allow manual control via chrome://flags.

[xiyuan, 2014/08/14 20:27:43]

We used to have one but it is removed now when turning the feature on by
default.

 #else
   // TODO(xiyuan): Revisit when non-chromeos platforms are supported.
   return false;
 #endif
 }
 
 void EasyUnlockService::Initialize() {
   registrar_.Init(profile_->GetPrefs());
   registrar_.Add(
       prefs::kEasyUnlockAllowed,
       base::Bind(&EasyUnlockService::OnPrefsChanged, base::Unretained(this)));
   OnPrefsChanged();
+
+  bluetooth_detector_->Initialize();
 }
 
 void EasyUnlockService::LoadApp() {
   DCHECK(IsAllowed());
 
 #if defined(GOOGLE_CHROME_BUILD)
   base::FilePath easy_unlock_path;
 #if defined(OS_CHROMEOS)
   easy_unlock_path = base::FilePath("/usr/share/chromeos-assets/easy_unlock");
 #endif  // defined(OS_CHROMEOS)
@@ skipping 11 matching lines @@
     GetComponentLoader(profile_)
         ->Add(IDR_EASY_UNLOCK_MANIFEST, easy_unlock_path);
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
 void EasyUnlockService::UnloadApp() {
   GetComponentLoader(profile_)->Remove(extension_misc::kEasyUnlockAppId);
 }
 
-void EasyUnlockService::OnPrefsChanged() {
+void EasyUnlockService::CheckIsAllowed() {

[Ilya Sherman, 2014/08/14 07:29:41]

nit: Perhaps name this something more like "UpdateAppState()"?

[xiyuan, 2014/08/14 20:27:43]

Done.

   if (IsAllowed())
     LoadApp();
   else
     UnloadApp();
 }
+
+void EasyUnlockService::OnPrefsChanged() {
+  CheckIsAllowed();
+}
+
+void EasyUnlockService::OnBluetoothAdapterPresentChanged() {
+  CheckIsAllowed();
+}
+