Runtime checks so that CoreBluetooth only used on >= 10.10

device/bluetooth/bluetooth_adapter_mac.mm

 // Copyright 2013 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 "device/bluetooth/bluetooth_adapter_mac.h"
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothHostController.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
+#include "base/mac/mac_util.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "device/bluetooth/bluetooth_classic_device_mac.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
@@ skipping 25 matching lines @@
   adapter->Init();
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 BluetoothAdapterMac::BluetoothAdapterMac()
     : BluetoothAdapter(),
       powered_(false),
       num_discovery_sessions_(0),
       classic_discovery_manager_(
           BluetoothDiscoveryManagerMac::CreateClassic(this)),
-      low_energy_discovery_manager_(
-          BluetoothLowEnergyDiscoveryManagerMac::Create(this)),
       weak_ptr_factory_(this) {
+  if (IsLowEnergyAvailable())
+    low_energy_discovery_manager_.reset(
+        BluetoothLowEnergyDiscoveryManagerMac::Create(this));
   DCHECK(classic_discovery_manager_.get());
 }
 
 BluetoothAdapterMac::~BluetoothAdapterMac() {
 }
 
 std::string BluetoothAdapterMac::GetAddress() const {
   return address_;
 }
 
@@ skipping 31 matching lines @@
 }
 
 void BluetoothAdapterMac::SetDiscoverable(
     bool discoverable,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
 }
 
 bool BluetoothAdapterMac::IsDiscovering() const {
-  return (classic_discovery_manager_->IsDiscovering() ||
-          low_energy_discovery_manager_->IsDiscovering());
+  bool is_discovering = classic_discovery_manager_->IsDiscovering();
+  if (IsLowEnergyAvailable())
+    is_discovering =
+        is_discovering || low_energy_discovery_manager_->IsDiscovering();
+  return is_discovering;
 }
 
 void BluetoothAdapterMac::CreateRfcommService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
   scoped_refptr<BluetoothSocketMac> socket = BluetoothSocketMac::CreateSocket();
   socket->ListenUsingRfcomm(
       this, uuid, options, base::Bind(callback, socket), error_callback);
@@ skipping 41 matching lines @@
 }
 
 void BluetoothAdapterMac::DeviceConnected(IOBluetoothDevice* device) {
   // TODO(isherman): Investigate whether this method can be replaced with a call
   // to +registerForConnectNotifications:selector:.
   DVLOG(1) << "Adapter registered a new connection from device with address: "
            << BluetoothClassicDeviceMac::GetDeviceAddress(device);
   ClassicDeviceAdded(device);
 }
 
+// static
+bool BluetoothAdapterMac::IsLowEnergyAvailable() {
+  return base::mac::IsOSYosemiteOrLater();
+}
+
 void BluetoothAdapterMac::RemovePairingDelegateInternal(
     BluetoothDevice::PairingDelegate* pairing_delegate) {
 }
 
 void BluetoothAdapterMac::AddDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DVLOG(1) << __func__;
   if (num_discovery_sessions_ > 0) {
@@ skipping 51 matching lines @@
     transport = discovery_filter->GetTransport();
 
   if (transport & BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC) {
     if (!classic_discovery_manager_->StopDiscovery()) {
       DVLOG(1) << "Failed to stop classic discovery";
       error_callback.Run();
       return;
     }
   }
   if (transport & BluetoothDiscoveryFilter::Transport::TRANSPORT_LE) {
-    low_energy_discovery_manager_->StopDiscovery();
+    if (IsLowEnergyAvailable())
+      low_energy_discovery_manager_->StopDiscovery();
   }
 
   DVLOG(1) << "Discovery stopped";
   num_discovery_sessions_--;
   callback.Run();
 }
 
 void BluetoothAdapterMac::SetDiscoveryFilter(
     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
     const base::Closure& callback,
@@ skipping 16 matching lines @@
     // TODO(krstnmnlsn): If a classic discovery session is already running then
     // we should update its filter. crbug.com/498056
     if (!classic_discovery_manager_->StartDiscovery()) {
       DVLOG(1) << "Failed to add a classic discovery session";
       return false;
     }
   }
   if (transport & BluetoothDiscoveryFilter::Transport::TRANSPORT_LE) {
     // Begin a low energy discovery session or update it if one is already
     // running.
-    low_energy_discovery_manager_->StartDiscovery(BluetoothDevice::UUIDList());
+    if (IsLowEnergyAvailable())
+      low_energy_discovery_manager_->StartDiscovery(
+          BluetoothDevice::UUIDList());
   }
   return true;
 }
 
 void BluetoothAdapterMac::Init() {
   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   PollAdapter();
 }
 
 void BluetoothAdapterMac::InitForTest(
@@ skipping 121 matching lines @@
     DCHECK_EQ(num_removed, 1U);
   }
 
   // Add any new paired devices.
   for (IOBluetoothDevice* device in [IOBluetoothDevice pairedDevices]) {
     ClassicDeviceAdded(device);
   }
 }
 
 }  // namespace device