Report Bluetooth adapter status to UMA.

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 "apps/app_lifetime_monitor.h"
 #include "apps/app_lifetime_monitor_factory.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 26 matching lines @@
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_factory.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #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
 
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#endif
+
 namespace {
 
+enum BluetoothType {
+  BT_NO_ADAPTER,
+  BT_NORMAL,
+  BT_LOW_ENERGY_CAPABLE,
+  BT_MAX_TYPE
+};
+
 PrefService* GetLocalState() {
   return g_browser_process ? g_browser_process->local_state() : NULL;
 }
 
 }  // namespace
 
 EasyUnlockService::UserSettings::UserSettings()
     : require_close_proximity(false) {
 }
 
@@ skipping 11 matching lines @@
 #if defined(OS_CHROMEOS)
   Profile* profile = chromeos::ProfileHelper::Get()->GetProfileByUser(&user);
   if (!profile)
     return NULL;
   return EasyUnlockService::Get(profile);
 #else
   return NULL;
 #endif
 }
 
+bool EasyUnlockService::bluetooth_adapter_has_been_reported;
+
 // static
 bool EasyUnlockService::IsSignInEnabled() {
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       proximity_auth::switches::kDisableEasyUnlock);
 }
 
 class EasyUnlockService::BluetoothDetector
     : public device::BluetoothAdapter::Observer,
       public apps::AppLifetimeMonitor::Observer {
  public:
@@ skipping 21 matching lines @@
   }
 
   bool IsPresent() const { return adapter_.get() && adapter_->IsPresent(); }
 
   // device::BluetoothAdapter::Observer:
   void AdapterPresentChanged(device::BluetoothAdapter* adapter,
                              bool present) override {
     service_->OnBluetoothAdapterPresentChanged();
   }
 
+  device::BluetoothAdapter* getAdapter() {
+    return adapter_.get();
+  }
+
  private:
   void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {
     adapter_ = adapter;
     adapter_->AddObserver(this);
     service_->OnBluetoothAdapterPresentChanged();
 
     // TODO(tengs): At the moment, there is no way for Bluetooth discoverability
     // to be turned on except through the Easy Unlock setup. If we step on any
     // toes in the future then we need to revisit this guard.
     if (adapter_->IsDiscoverable())
       TurnOffBluetoothDiscoverability();
+
+#if !defined(OS_CHROMEOS)
+    // Bluetooth detection causes serious performance degradations on Mac
+    // and possibly other platforms as well: http://crbug.com/467316
+    // Since this feature is currently only offered for ChromeOS we just
+    // turn it off on other platforms once the inforamtion about the
+    // adapter has been gathered and reported.
+    // TODO(bcwhite,xiyuan): Revisit when non-chromeos platforms are supported.
+    adapter_->RemoveObserver(this);
+    adapter_ = NULL;
+#endif  // !defined(OS_CHROMEOS)
   }
 
   // apps::AppLifetimeMonitor::Observer:
   void OnAppDeactivated(Profile* profile, const std::string& app_id) override {
     // TODO(tengs): Refactor the lifetime management to EasyUnlockAppManager.
     if (app_id == extension_misc::kEasyUnlockAppId)
       TurnOffBluetoothDiscoverability();
   }
 
   void OnAppStop(Profile* profile, const std::string& app_id) override {
@@ skipping 512 matching lines @@
   if (screenlock_state_handler_)
     screenlock_state_handler_->SetHardlockState(state);
   if (state != EasyUnlockScreenlockStateHandler::NO_HARDLOCK)
     auth_attempt_.reset();
 }
 
 void EasyUnlockService::InitializeOnAppManagerReady() {
   CHECK(app_manager_.get());
 
   InitializeInternal();
-
-#if defined(OS_CHROMEOS)
-  // Only start Bluetooth detection for ChromeOS since the feature is
-  // only offered on ChromeOS. Enabling this on non-ChromeOS platforms
-  // previously introduced a performance regression: http://crbug.com/404482
-  // Make sure not to reintroduce a performance regression if re-enabling on
-  // additional platforms.
-  // TODO(xiyuan): Revisit when non-chromeos platforms are supported.
   bluetooth_detector_->Initialize();
-#endif  // defined(OS_CHROMEOS)
 }
 
 void EasyUnlockService::OnBluetoothAdapterPresentChanged() {
   UpdateAppState();
+
+  if (!bluetooth_adapter_has_been_reported) {
+    bluetooth_adapter_has_been_reported = true;
+    int bttype = BT_NO_ADAPTER;
+    if (bluetooth_detector_->IsPresent()) {
+      bttype = BT_LOW_ENERGY_CAPABLE;
+#if defined(OS_WIN)
+      if (base::win::GetVersion() < base::win::VERSION_WIN8) {
+        bttype = BT_NORMAL;
+      }
+#endif
+    }
+    UMA_HISTOGRAM_ENUMERATION(
+      "EasyUnlock.BluetoothAvailability", bttype, BT_MAX_TYPE);
+  }
 }
 
 void EasyUnlockService::SetHardlockStateForUser(
       const std::string& user_id,
       EasyUnlockScreenlockStateHandler::HardlockState state) {
   DCHECK(!user_id.empty());
 
   PrefService* local_state = GetLocalState();
   if (!local_state)
     return;
@@ skipping 111 matching lines @@
 
   // TODO(tbarzic): Set check_private_key only if previous sign-in attempt
   // failed.
   EasyUnlockTpmKeyManagerFactory::GetInstance()->Get(profile_)
       ->PrepareTpmKey(true /* check_private_key */,
                       base::Closure());
 #endif  // defined(OS_CHROMEOS)
 
   tpm_key_checked_ = true;
 }