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/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_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 "components/user_manager/user_manager.h"
 #endif
 
 namespace {
@@ skipping 15 matching lines @@
   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) {
+  }
+
+  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 {
+    service_->OnBluetoothAdapterPresentChanged();
+  }
+
+ private:
+  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {
+    adapter_ = adapter;
+    adapter_->AddObserver(this);
+    service_->OnBluetoothAdapterPresentChanged();
+  }
+
+  // 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);
+};
+
 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()));
 }
 
 EasyUnlockService::~EasyUnlockService() {
 }
@@ skipping 33 matching lines @@
 #if defined(OS_CHROMEOS)
   if (!user_manager::UserManager::Get()->IsLoggedInAsRegularUser())
     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.
-  return base::FieldTrialList::FindFullName("EasyUnlock") != "Disable";
+  // It is disabled when the trial exists and is in "Disable" group.
+  if (base::FieldTrialList::FindFullName("EasyUnlock") == "Disable")
+    return false;
+
+  if (!bluetooth_detector_->IsPresent())
+    return false;
+
+  return true;
 #else
   // TODO(xiyuan): Revisit when non-chromeos platforms are supported.
   return false;
 #endif
 }
 
 EasyUnlockScreenlockStateHandler*
     EasyUnlockService::GetScreenlockStateHandler() {
   if (!IsAllowed())
     return NULL;
@@ skipping 97 matching lines @@
   turn_off_flow_.reset();
   SetTurnOffFlowStatus(IDLE);
 }
 
 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)
 
 #ifndef NDEBUG
   // 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()) {
-    GetComponentLoader(profile_)
-        ->Add(IDR_EASY_UNLOCK_MANIFEST, easy_unlock_path);
+    extensions::ComponentLoader* loader = GetComponentLoader(profile_);
+    if (!loader->Exists(extension_misc::kEasyUnlockAppId))
+      loader->Add(IDR_EASY_UNLOCK_MANIFEST, easy_unlock_path);
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
 void EasyUnlockService::UnloadApp() {
-  GetComponentLoader(profile_)->Remove(extension_misc::kEasyUnlockAppId);
+  extensions::ComponentLoader* loader = GetComponentLoader(profile_);
+  if (loader->Exists(extension_misc::kEasyUnlockAppId))
+    loader->Remove(extension_misc::kEasyUnlockAppId);
 }
 
-void EasyUnlockService::OnPrefsChanged() {
+void EasyUnlockService::UpdateAppState() {
   if (IsAllowed()) {
     LoadApp();
   } else {
     UnloadApp();
     // Reset the screenlock state handler to make sure Screenlock state set
     // by Easy Unlock app is reset.
     screenlock_state_handler_.reset();
   }
 }
 
+void EasyUnlockService::OnPrefsChanged() {
+  UpdateAppState();
+}
+
+void EasyUnlockService::OnBluetoothAdapterPresentChanged() {
+  UpdateAppState();
+}
+
 void EasyUnlockService::SetTurnOffFlowStatus(TurnOffFlowStatus status) {
   turn_off_flow_status_ = status;
   FOR_EACH_OBSERVER(
       EasyUnlockServiceObserver, observers_, OnTurnOffOperationStatusChanged());
 }
 
 void EasyUnlockService::OnTurnOffFlowFinished(bool success) {
   turn_off_flow_.reset();
 
   if (!success) {
     SetTurnOffFlowStatus(FAIL);
     return;
   }
 
   ClearRemoteDevices();
   SetTurnOffFlowStatus(IDLE);
 
   if (GetComponentLoader(profile_)->Exists(extension_misc::kEasyUnlockAppId)) {
     extensions::ExtensionSystem* extension_system =
         extensions::ExtensionSystem::Get(profile_);
     extension_system->extension_service()->ReloadExtension(
         extension_misc::kEasyUnlockAppId);
   }
 }