[CrOS Tether] Rate-limit BLE discovery sessions.

There are race conditions in Bluetooth which can cause errors when
starting and stopping discovery sessions too close to one another.
In the worst case, these issues can cause a crash.

This CL rate-limits BLE advertisements and scans to at most one per
200ms. This reduces the possibility of race conditions in the kernel.

Bug: 768523, 672263
Change-Id: I985aec16b6f9cd80c385ab9af199daff4fb50ced
Reviewed-on: https://chromium-review.googlesource.com/683756Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#504291}

chromeos/components/tether/BUILD.gn

@@ -12,8 +12,6 @@ static_library("tether") {
     "active_host_network_state_updater.h",
     "ble_advertisement_device_queue.cc",
     "ble_advertisement_device_queue.h",
-    "ble_advertisement_synchronizer.cc",
-    "ble_advertisement_synchronizer.h",
     "ble_advertiser.cc",
     "ble_advertiser.h",
     "ble_connection_manager.cc",
@@ -21,6 +19,8 @@ static_library("tether") {
     "ble_constants.h",
     "ble_scanner.cc",
     "ble_scanner.h",
+    "ble_synchronizer.cc",
+    "ble_synchronizer.h",
     "connect_tethering_operation.cc",
     "connect_tethering_operation.h",
     "crash_recovery_manager.cc",
@@ -130,10 +130,10 @@ static_library("test_support") {
   sources = [
     "fake_active_host.cc",
     "fake_active_host.h",
-    "fake_ble_advertisement_synchronizer.cc",
-    "fake_ble_advertisement_synchronizer.h",
     "fake_ble_connection_manager.cc",
     "fake_ble_connection_manager.h",
+    "fake_ble_synchronizer.cc",
+    "fake_ble_synchronizer.h",
     "fake_disconnect_tethering_request_sender.cc",
     "fake_disconnect_tethering_request_sender.h",
     "fake_error_tolerant_ble_advertisement.cc",
@@ -189,10 +189,10 @@ source_set("unit_tests") {
     "active_host_network_state_updater_unittest.cc",
     "active_host_unittest.cc",
     "ble_advertisement_device_queue_unittest.cc",
-    "ble_advertisement_synchronizer_unittest.cc",
     "ble_advertiser_unittest.cc",
     "ble_connection_manager_unittest.cc",
     "ble_scanner_unittest.cc",
+    "ble_synchronizer_unittest.cc",
     "connect_tethering_operation_unittest.cc",
     "crash_recovery_manager_unittest.cc",
     "device_status_util_unittest.cc",

chromeos/components/tether/ble_advertiser.cc

@@ -26,10 +26,10 @@ BleAdvertiser::AdvertisementMetadata::~AdvertisementMetadata() {}
 BleAdvertiser::BleAdvertiser(
     cryptauth::LocalDeviceDataProvider* local_device_data_provider,
     cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
-    BleAdvertisementSynchronizer* ble_advertisement_synchronizer)
+    BleSynchronizer* ble_synchronizer)
     : remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher),
       local_device_data_provider_(local_device_data_provider),
-      ble_advertisement_synchronizer_(ble_advertisement_synchronizer),
+      ble_synchronizer_(ble_synchronizer),
       eid_generator_(base::MakeUnique<cryptauth::ForegroundEidGenerator>()),
       weak_ptr_factory_(this) {}
 
@@ -154,7 +154,7 @@ void BleAdvertiser::UpdateAdvertisements() {
       advertisements_[i] =
           ErrorTolerantBleAdvertisementImpl::Factory::NewInstance(
               metadata->device_id, std::move(service_data_copy),
-              ble_advertisement_synchronizer_);
+              ble_synchronizer_);
       continue;
     }
 

chromeos/components/tether/ble_advertiser.h

@@ -27,7 +27,7 @@ namespace chromeos {
 
 namespace tether {
 
-class BleAdvertisementSynchronizer;
+class BleSynchronizer;
 class ErrorTolerantBleAdvertisement;
 
 // Advertises to a given device. When StartAdvertisingToDevice() is called, a
@@ -47,7 +47,7 @@ class BleAdvertiser {
 
   BleAdvertiser(cryptauth::LocalDeviceDataProvider* local_device_data_provider,
                 cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
-                BleAdvertisementSynchronizer* ble_advertisement_synchronizer_);
+                BleSynchronizer* ble_synchronizer);
   virtual ~BleAdvertiser();
 
   virtual bool StartAdvertisingToDevice(
@@ -84,7 +84,7 @@ class BleAdvertiser {
 
   cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher_;
   cryptauth::LocalDeviceDataProvider* local_device_data_provider_;
-  BleAdvertisementSynchronizer* ble_advertisement_synchronizer_;
+  BleSynchronizer* ble_synchronizer_;
 
   std::unique_ptr<cryptauth::ForegroundEidGenerator> eid_generator_;
 

chromeos/components/tether/ble_advertiser_unittest.cc

@@ -9,7 +9,7 @@
 #include "base/stl_util.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/error_tolerant_ble_advertisement_impl.h"
-#include "chromeos/components/tether/fake_ble_advertisement_synchronizer.h"
+#include "chromeos/components/tether/fake_ble_synchronizer.h"
 #include "chromeos/components/tether/fake_error_tolerant_ble_advertisement.h"
 #include "components/cryptauth/mock_foreground_eid_generator.h"
 #include "components/cryptauth/mock_local_device_data_provider.h"
@@ -72,7 +72,7 @@ class FakeErrorTolerantBleAdvertisementFactory
   std::unique_ptr<ErrorTolerantBleAdvertisement> BuildInstance(
       const std::string& device_id,
       std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-      BleAdvertisementSynchronizer* ble_advertisement_synchronizer) override {
+      BleSynchronizer* ble_synchronizer) override {
     FakeErrorTolerantBleAdvertisement* fake_advertisement =
         new FakeErrorTolerantBleAdvertisement(
             device_id, base::Bind(&FakeErrorTolerantBleAdvertisementFactory::
@@ -151,8 +151,7 @@ class BleAdvertiserTest : public testing::Test {
     mock_local_data_provider_->SetPublicKey(
         base::MakeUnique<std::string>(kFakePublicKey));
 
-    fake_ble_advertisement_synchronizer_ =
-        base::MakeUnique<FakeBleAdvertisementSynchronizer>();
+    fake_ble_synchronizer_ = base::MakeUnique<FakeBleSynchronizer>();
 
     fake_advertisement_factory_ =
         base::WrapUnique(new FakeErrorTolerantBleAdvertisementFactory());
@@ -163,7 +162,7 @@ class BleAdvertiserTest : public testing::Test {
 
     ble_advertiser_ = base::MakeUnique<BleAdvertiser>(
         mock_local_data_provider_.get(), mock_seed_fetcher_.get(),
-        fake_ble_advertisement_synchronizer_.get());
+        fake_ble_synchronizer_.get());
     ble_advertiser_->SetEidGeneratorForTest(std::move(eid_generator));
     ble_advertiser_->AddObserver(test_observer_.get());
   }
@@ -199,8 +198,7 @@ class BleAdvertiserTest : public testing::Test {
   std::unique_ptr<cryptauth::MockRemoteBeaconSeedFetcher> mock_seed_fetcher_;
   std::unique_ptr<cryptauth::MockLocalDeviceDataProvider>
       mock_local_data_provider_;
-  std::unique_ptr<FakeBleAdvertisementSynchronizer>
-      fake_ble_advertisement_synchronizer_;
+  std::unique_ptr<FakeBleSynchronizer> fake_ble_synchronizer_;
 
   std::unique_ptr<TestObserver> test_observer_;
 

chromeos/components/tether/ble_connection_manager_unittest.cc

@@ -148,7 +148,7 @@ class UnregisteringObserver : public BleConnectionManager::Observer {
 class MockBleScanner : public BleScanner {
  public:
   explicit MockBleScanner(scoped_refptr<device::BluetoothAdapter> adapter)
-      : BleScanner(adapter, nullptr) {}
+      : BleScanner(adapter, nullptr, nullptr) {}
   ~MockBleScanner() override {}
 
   MOCK_METHOD1(RegisterScanFilterForDevice,

chromeos/components/tether/ble_scanner.cc

@@ -8,6 +8,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "chromeos/components/tether/ble_constants.h"
+#include "chromeos/components/tether/ble_synchronizer.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/proximity_auth/logging/logging.h"
@@ -41,21 +42,13 @@ BleScanner::ServiceDataProviderImpl::GetServiceDataForUUID(
 
 BleScanner::BleScanner(
     scoped_refptr<device::BluetoothAdapter> adapter,
-    const cryptauth::LocalDeviceDataProvider* local_device_data_provider)
-    : BleScanner(base::MakeUnique<ServiceDataProviderImpl>(),
-                 adapter,
-                 base::WrapUnique(new cryptauth::ForegroundEidGenerator()),
-                 local_device_data_provider) {}
-
-BleScanner::BleScanner(
-    std::unique_ptr<ServiceDataProvider> service_data_provider,
-    scoped_refptr<device::BluetoothAdapter> adapter,
-    std::unique_ptr<cryptauth::ForegroundEidGenerator> eid_generator,
-    const cryptauth::LocalDeviceDataProvider* local_device_data_provider)
-    : service_data_provider_(std::move(service_data_provider)),
-      adapter_(adapter),
-      eid_generator_(std::move(eid_generator)),
+    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
+    BleSynchronizer* ble_synchronizer)
+    : adapter_(adapter),
       local_device_data_provider_(local_device_data_provider),
+      ble_synchronizer_(ble_synchronizer),
+      service_data_provider_(base::MakeUnique<ServiceDataProviderImpl>()),
+      eid_generator_(base::MakeUnique<cryptauth::ForegroundEidGenerator>()),
       weak_ptr_factory_(this) {
   adapter_->AddObserver(this);
 }
@@ -127,6 +120,13 @@ bool BleScanner::IsDiscoverySessionActive() {
   return false;
 }
 
+void BleScanner::SetTestDoubles(
+    std::unique_ptr<ServiceDataProvider> service_data_provider,
+    std::unique_ptr<cryptauth::ForegroundEidGenerator> eid_generator) {
+  service_data_provider_ = std::move(service_data_provider);
+  eid_generator_ = std::move(eid_generator);
+}
+
 bool BleScanner::IsDeviceRegistered(const std::string& device_id) {
   for (auto it = registered_remote_devices_.begin();
        it != registered_remote_devices_.end(); ++it) {
@@ -184,6 +184,7 @@ void BleScanner::ResetDiscoverySessionIfNotActive() {
   // properly. When we detect that this situation has occurred, delete the
   // pointer and reset discovery state.
   discovery_session_.reset();
+  discovery_session_weak_ptr_factory_.reset();
   is_initializing_discovery_session_ = false;
   is_stopping_discovery_session_ = false;
   weak_ptr_factory_.InvalidateWeakPtrs();
@@ -199,8 +200,6 @@ void BleScanner::UpdateDiscoveryStatus() {
 }
 
 void BleScanner::EnsureDiscoverySessionActive() {
-  DCHECK(adapter_);
-
   // If the session is active or is in the process of becoming active, there is
   // nothing to do.
   if (IsDiscoverySessionActive() || is_initializing_discovery_session_)
@@ -208,13 +207,7 @@ void BleScanner::EnsureDiscoverySessionActive() {
 
   is_initializing_discovery_session_ = true;
 
-  // Note: Ideally, we would use a filter for only LE devices here. However,
-  // using a filter here triggers a bug in some kernel implementations which
-  // causes LE scanning to toggle rapidly on and off. This can cause race
-  // conditions which result in Bluetooth bugs. See crbug.com/759090.
-  // TODO(mcchou): Once these issues have been resolved, add the filter back.
-  // See crbug.com/759091.
-  adapter_->StartDiscoverySession(
+  ble_synchronizer_->StartDiscoverySession(
       base::Bind(&BleScanner::OnDiscoverySessionStarted,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&BleScanner::OnStartDiscoverySessionError,
@@ -224,7 +217,12 @@ void BleScanner::EnsureDiscoverySessionActive() {
 void BleScanner::OnDiscoverySessionStarted(
     std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   is_initializing_discovery_session_ = false;
+  PA_LOG(INFO) << "Started discovery session successfully.";
+
   discovery_session_ = std::move(discovery_session);
+  discovery_session_weak_ptr_factory_ =
+      base::MakeUnique<base::WeakPtrFactory<device::BluetoothDiscoverySession>>(
+          discovery_session_.get());
 
   NotifyDiscoverySessionStateChanged(true /* discovery_session_active */);
 
@@ -232,7 +230,7 @@ void BleScanner::OnDiscoverySessionStarted(
 }
 
 void BleScanner::OnStartDiscoverySessionError() {
-  PA_LOG(WARNING) << "Error starting discovery session. Initialization failed.";
+  PA_LOG(ERROR) << "Error starting discovery session. Initialization failed.";
   is_initializing_discovery_session_ = false;
   UpdateDiscoveryStatus();
 }
@@ -244,15 +242,20 @@ void BleScanner::EnsureDiscoverySessionNotActive() {
 
   is_stopping_discovery_session_ = true;
 
-  discovery_session_->Stop(base::Bind(&BleScanner::OnDiscoverySessionStopped,
-                                      weak_ptr_factory_.GetWeakPtr()),
-                           base::Bind(&BleScanner::OnStopDiscoverySessionError,
-                                      weak_ptr_factory_.GetWeakPtr()));
+  ble_synchronizer_->StopDiscoverySession(
+      discovery_session_weak_ptr_factory_->GetWeakPtr(),
+      base::Bind(&BleScanner::OnDiscoverySessionStopped,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&BleScanner::OnStopDiscoverySessionError,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BleScanner::OnDiscoverySessionStopped() {
   is_stopping_discovery_session_ = false;
+  PA_LOG(INFO) << "Stopped discovery session successfully.";
+
   discovery_session_.reset();
+  discovery_session_weak_ptr_factory_.reset();
 
   NotifyDiscoverySessionStateChanged(false /* discovery_session_active */);
 
@@ -260,7 +263,7 @@ void BleScanner::OnDiscoverySessionStopped() {
 }
 
 void BleScanner::OnStopDiscoverySessionError() {
-  PA_LOG(WARNING) << "Error stopping discovery session.";
+  PA_LOG(ERROR) << "Error stopping discovery session.";
   is_stopping_discovery_session_ = false;
   UpdateDiscoveryStatus();
 }

chromeos/components/tether/ble_scanner.h

@@ -25,6 +25,9 @@ namespace chromeos {
 
 namespace tether {
 
+class BleSynchronizer;
+
+// Performs BLE scans for devices which are advertising to this device.
 class BleScanner : public device::BluetoothAdapter::Observer {
  public:
   class Observer {
@@ -36,9 +39,9 @@ class BleScanner : public device::BluetoothAdapter::Observer {
     }
   };
 
-  BleScanner(
-      scoped_refptr<device::BluetoothAdapter> adapter,
-      const cryptauth::LocalDeviceDataProvider* local_device_data_provider);
+  BleScanner(scoped_refptr<device::BluetoothAdapter> adapter,
+             cryptauth::LocalDeviceDataProvider* local_device_data_provider,
+             BleSynchronizer* ble_synchronizer);
   ~BleScanner() override;
 
   virtual bool RegisterScanFilterForDevice(
@@ -87,11 +90,9 @@ class BleScanner : public device::BluetoothAdapter::Observer {
         device::BluetoothDevice* bluetooth_device) override;
   };
 
-  BleScanner(
+  void SetTestDoubles(
       std::unique_ptr<ServiceDataProvider> service_data_provider,
-      scoped_refptr<device::BluetoothAdapter> adapter,
-      std::unique_ptr<cryptauth::ForegroundEidGenerator> eid_generator,
-      const cryptauth::LocalDeviceDataProvider* local_device_data_provider);
+      std::unique_ptr<cryptauth::ForegroundEidGenerator> eid_generator);
 
   bool IsDeviceRegistered(const std::string& device_id);
 
@@ -116,22 +117,22 @@ class BleScanner : public device::BluetoothAdapter::Observer {
   void CheckForMatchingScanFilters(device::BluetoothDevice* bluetooth_device,
                                    std::string& service_data);
 
-  base::ObserverList<Observer> observer_list_;
-
-  std::unique_ptr<ServiceDataProvider> service_data_provider_;
 
   scoped_refptr<device::BluetoothAdapter> adapter_;
+  cryptauth::LocalDeviceDataProvider* local_device_data_provider_;
+  BleSynchronizer* ble_synchronizer_;
 
+  std::unique_ptr<ServiceDataProvider> service_data_provider_;
   std::unique_ptr<cryptauth::ForegroundEidGenerator> eid_generator_;
-  // |local_device_data_provider_| is not owned by this instance and must
-  // outlive it.
-  const cryptauth::LocalDeviceDataProvider* local_device_data_provider_;
+
+  std::vector<cryptauth::RemoteDevice> registered_remote_devices_;
+  base::ObserverList<Observer> observer_list_;
 
   bool is_initializing_discovery_session_ = false;
   bool is_stopping_discovery_session_ = false;
   std::unique_ptr<device::BluetoothDiscoverySession> discovery_session_;
-
-  std::vector<cryptauth::RemoteDevice> registered_remote_devices_;
+  std::unique_ptr<base::WeakPtrFactory<device::BluetoothDiscoverySession>>
+      discovery_session_weak_ptr_factory_;
 
   base::WeakPtrFactory<BleScanner> weak_ptr_factory_;
 

chromeos/components/tether/ble_advertisement_synchronizer.cc → chromeos/components/tether/ble_synchronizer.cc

@@ -2,10 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chromeos/components/tether/ble_advertisement_synchronizer.h"
+#include "chromeos/components/tether/ble_synchronizer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/time/default_clock.h"
+#include "components/proximity_auth/logging/logging.h"
 
 namespace chromeos {
 
@@ -13,11 +14,11 @@ namespace tether {
 
 namespace {
 
-int64_t kTimeBetweenEachCommandMs = 200;
+const int64_t kTimeBetweenEachCommandMs = 200;
 
 }  // namespace
 
-BleAdvertisementSynchronizer::RegisterArgs::RegisterArgs(
+BleSynchronizer::RegisterArgs::RegisterArgs(
     std::unique_ptr<device::BluetoothAdvertisement::Data> advertisement_data,
     const device::BluetoothAdapter::CreateAdvertisementCallback& callback,
     const device::BluetoothAdapter::AdvertisementErrorCallback& error_callback)
@@ -25,9 +26,9 @@ BleAdvertisementSynchronizer::RegisterArgs::RegisterArgs(
       callback(callback),
       error_callback(error_callback) {}
 
-BleAdvertisementSynchronizer::RegisterArgs::~RegisterArgs() {}
+BleSynchronizer::RegisterArgs::~RegisterArgs() {}
 
-BleAdvertisementSynchronizer::UnregisterArgs::UnregisterArgs(
+BleSynchronizer::UnregisterArgs::UnregisterArgs(
     scoped_refptr<device::BluetoothAdvertisement> advertisement,
     const device::BluetoothAdvertisement::SuccessCallback& callback,
     const device::BluetoothAdvertisement::ErrorCallback& error_callback)
@@ -35,30 +36,56 @@ BleAdvertisementSynchronizer::UnregisterArgs::UnregisterArgs(
       callback(callback),
       error_callback(error_callback) {}
 
-BleAdvertisementSynchronizer::UnregisterArgs::~UnregisterArgs() {}
+BleSynchronizer::UnregisterArgs::~UnregisterArgs() {}
 
-BleAdvertisementSynchronizer::Command::Command(
-    std::unique_ptr<RegisterArgs> register_args)
+BleSynchronizer::StartDiscoveryArgs::StartDiscoveryArgs(
+    const device::BluetoothAdapter::DiscoverySessionCallback& callback,
+    const device::BluetoothAdapter::ErrorCallback& error_callback)
+    : callback(callback), error_callback(error_callback) {}
+
+BleSynchronizer::StartDiscoveryArgs::~StartDiscoveryArgs() {}
+
+BleSynchronizer::StopDiscoveryArgs::StopDiscoveryArgs(
+    base::WeakPtr<device::BluetoothDiscoverySession> discovery_session,
+    const base::Closure& callback,
+    const device::BluetoothDiscoverySession::ErrorCallback& error_callback)
+    : discovery_session(discovery_session),
+      callback(callback),
+      error_callback(error_callback) {}
+
+BleSynchronizer::StopDiscoveryArgs::~StopDiscoveryArgs() {}
+
+BleSynchronizer::Command::Command(std::unique_ptr<RegisterArgs> register_args)
     : command_type(CommandType::REGISTER_ADVERTISEMENT),
       register_args(std::move(register_args)) {}
 
-BleAdvertisementSynchronizer::Command::Command(
+BleSynchronizer::Command::Command(
     std::unique_ptr<UnregisterArgs> unregister_args)
     : command_type(CommandType::UNREGISTER_ADVERTISEMENT),
       unregister_args(std::move(unregister_args)) {}
 
-BleAdvertisementSynchronizer::Command::~Command() {}
+BleSynchronizer::Command::Command(
+    std::unique_ptr<StartDiscoveryArgs> start_discovery_args)
+    : command_type(CommandType::START_DISCOVERY),
+      start_discovery_args(std::move(start_discovery_args)) {}
+
+BleSynchronizer::Command::Command(
+    std::unique_ptr<StopDiscoveryArgs> stop_discovery_args)
+    : command_type(CommandType::STOP_DISCOVERY),
+      stop_discovery_args(std::move(stop_discovery_args)) {}
 
-BleAdvertisementSynchronizer::BleAdvertisementSynchronizer(
+BleSynchronizer::Command::~Command() {}
+
+BleSynchronizer::BleSynchronizer(
     scoped_refptr<device::BluetoothAdapter> bluetooth_adapter)
     : bluetooth_adapter_(bluetooth_adapter),
       timer_(base::MakeUnique<base::OneShotTimer>()),
       clock_(base::MakeUnique<base::DefaultClock>()),
       weak_ptr_factory_(this) {}
 
-BleAdvertisementSynchronizer::~BleAdvertisementSynchronizer() {}
+BleSynchronizer::~BleSynchronizer() {}
 
-void BleAdvertisementSynchronizer::RegisterAdvertisement(
+void BleSynchronizer::RegisterAdvertisement(
     std::unique_ptr<device::BluetoothAdvertisement::Data> advertisement_data,
     const device::BluetoothAdapter::CreateAdvertisementCallback& callback,
     const device::BluetoothAdapter::AdvertisementErrorCallback&
@@ -68,7 +95,7 @@ void BleAdvertisementSynchronizer::RegisterAdvertisement(
   ProcessQueue();
 }
 
-void BleAdvertisementSynchronizer::UnregisterAdvertisement(
+void BleSynchronizer::UnregisterAdvertisement(
     scoped_refptr<device::BluetoothAdvertisement> advertisement,
     const device::BluetoothAdvertisement::SuccessCallback& callback,
     const device::BluetoothAdvertisement::ErrorCallback& error_callback) {
@@ -77,7 +104,24 @@ void BleAdvertisementSynchronizer::UnregisterAdvertisement(
   ProcessQueue();
 }
 
-void BleAdvertisementSynchronizer::ProcessQueue() {
+void BleSynchronizer::StartDiscoverySession(
+    const device::BluetoothAdapter::DiscoverySessionCallback& callback,
+    const device::BluetoothAdapter::ErrorCallback& error_callback) {
+  command_queue_.emplace_back(
+      base::MakeUnique<StartDiscoveryArgs>(callback, error_callback));
+  ProcessQueue();
+}
+
+void BleSynchronizer::StopDiscoverySession(
+    base::WeakPtr<device::BluetoothDiscoverySession> discovery_session,
+    const base::Closure& callback,
+    const device::BluetoothDiscoverySession::ErrorCallback& error_callback) {
+  command_queue_.emplace_back(base::MakeUnique<StopDiscoveryArgs>(
+      discovery_session, callback, error_callback));
+  ProcessQueue();
+}
+
+void BleSynchronizer::ProcessQueue() {
   if (command_queue_.empty())
     return;
 
@@ -98,31 +142,65 @@ void BleAdvertisementSynchronizer::ProcessQueue() {
           base::TimeDelta::FromMilliseconds(kTimeBetweenEachCommandMs)) {
     timer_->Start(FROM_HERE,
                   base::TimeDelta::FromMilliseconds(kTimeBetweenEachCommandMs),
-                  base::Bind(&BleAdvertisementSynchronizer::ProcessQueue,
+                  base::Bind(&BleSynchronizer::ProcessQueue,
                              weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   last_command_timestamp_ = current_timestamp;
 
-  if (command_queue_.front().command_type ==
-      CommandType::REGISTER_ADVERTISEMENT) {
-    RegisterArgs* register_args = command_queue_.front().register_args.get();
-    DCHECK(register_args);
-
-    bluetooth_adapter_->RegisterAdvertisement(
-        std::move(register_args->advertisement_data), register_args->callback,
-        register_args->error_callback);
-  } else {
-    DCHECK(command_queue_.front().command_type ==
-           CommandType::UNREGISTER_ADVERTISEMENT);
-
-    UnregisterArgs* unregister_args =
-        command_queue_.front().unregister_args.get();
-    DCHECK(unregister_args);
-
-    unregister_args->advertisement->Unregister(unregister_args->callback,
-                                               unregister_args->error_callback);
+  switch (command_queue_.front().command_type) {
+    case CommandType::REGISTER_ADVERTISEMENT: {
+      RegisterArgs* register_args = command_queue_.front().register_args.get();
+      DCHECK(register_args);
+      bluetooth_adapter_->RegisterAdvertisement(
+          std::move(register_args->advertisement_data), register_args->callback,
+          register_args->error_callback);
+      break;
+    }
+    case CommandType::UNREGISTER_ADVERTISEMENT: {
+      UnregisterArgs* unregister_args =
+          command_queue_.front().unregister_args.get();
+      DCHECK(unregister_args);
+      unregister_args->advertisement->Unregister(
+          unregister_args->callback, unregister_args->error_callback);
+      break;
+    }
+    case CommandType::START_DISCOVERY: {
+      StartDiscoveryArgs* start_discovery_args =
+          command_queue_.front().start_discovery_args.get();
+      DCHECK(start_discovery_args);
+
+      // Note: Ideally, we would use a filter for only LE devices here. However,
+      // using a filter here triggers a bug in some kernel implementations which
+      // causes LE scanning to toggle rapidly on and off. This can cause race
+      // conditions which result in Bluetooth bugs. See crbug.com/759090.
+      // TODO(mcchou): Once these issues have been resolved, add the filter
+      // back. See crbug.com/759091.
+      bluetooth_adapter_->StartDiscoverySession(
+          start_discovery_args->callback, start_discovery_args->error_callback);
+      break;
+    }
+    case CommandType::STOP_DISCOVERY: {
+      StopDiscoveryArgs* stop_discovery_args =
+          command_queue_.front().stop_discovery_args.get();
+      DCHECK(stop_discovery_args);
+
+      // If the discovery session has been deleted, there is nothing to stop.
+      if (!stop_discovery_args->discovery_session.get()) {
+        PA_LOG(WARNING) << "Could not process \"stop discovery\" command "
+                        << "because the DiscoverySession object passed is "
+                        << "deleted.";
+        break;
+      }
+
+      stop_discovery_args->discovery_session->Stop(
+          stop_discovery_args->callback, stop_discovery_args->error_callback);
+      break;
+    }
+    default:
+      NOTREACHED();
+      return;
   }
 
   command_queue_.pop_front();
@@ -130,9 +208,8 @@ void BleAdvertisementSynchronizer::ProcessQueue() {
   ProcessQueue();
 }
 
-void BleAdvertisementSynchronizer::SetTestDoubles(
-    std::unique_ptr<base::Timer> test_timer,
-    std::unique_ptr<base::Clock> test_clock) {
+void BleSynchronizer::SetTestDoubles(std::unique_ptr<base::Timer> test_timer,
+                                     std::unique_ptr<base::Clock> test_clock) {
   timer_ = std::move(test_timer);
   clock_ = std::move(test_clock);
 }

chromeos/components/tether/ble_advertisement_synchronizer.h → chromeos/components/tether/ble_synchronizer.h

@@ -15,34 +15,49 @@
 #include "base/timer/timer.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
+#include "device/bluetooth/bluetooth_discovery_session.h"
 
 namespace chromeos {
 
 namespace tether {
 
-// Ensures that BLE advertisement registration/unregistration commands are not
-// sent back-to-back. Because Bluetooth race conditions exist in the kernel,
-// this strategy is necessary to work around potential bugs. Essentially, this
-// class is a synchronization wrapper around the Bluetooth API.
-class BleAdvertisementSynchronizer {
+// Ensures that BLE advertisement registration/unregistration commands and
+// discovery start/stop are not sent too close to each other. Because Bluetooth
+// race conditions exist in the kernel, this strategy is necessary to work
+// around potential bugs. Essentially, this class is a synchronization wrapper
+// around the Bluetooth API.
+class BleSynchronizer {
  public:
-  BleAdvertisementSynchronizer(
-      scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
-  virtual ~BleAdvertisementSynchronizer();
+  BleSynchronizer(scoped_refptr<device::BluetoothAdapter> bluetooth_adapter);
+  virtual ~BleSynchronizer();
 
+  // Advertisement wrappers.
   void RegisterAdvertisement(
       std::unique_ptr<device::BluetoothAdvertisement::Data> advertisement_data,
       const device::BluetoothAdapter::CreateAdvertisementCallback& callback,
       const device::BluetoothAdapter::AdvertisementErrorCallback&
           error_callback);
-
   void UnregisterAdvertisement(
       scoped_refptr<device::BluetoothAdvertisement> advertisement,
       const device::BluetoothAdvertisement::SuccessCallback& success_callback,
       const device::BluetoothAdvertisement::ErrorCallback& error_callback);
 
+  // Discovery session wrappers.
+  void StartDiscoverySession(
+      const device::BluetoothAdapter::DiscoverySessionCallback& callback,
+      const device::BluetoothAdapter::ErrorCallback& error_callback);
+  void StopDiscoverySession(
+      base::WeakPtr<device::BluetoothDiscoverySession> discovery_session,
+      const base::Closure& callback,
+      const device::BluetoothDiscoverySession::ErrorCallback& error_callback);
+
  protected:
-  enum class CommandType { REGISTER_ADVERTISEMENT, UNREGISTER_ADVERTISEMENT };
+  enum class CommandType {
+    REGISTER_ADVERTISEMENT,
+    UNREGISTER_ADVERTISEMENT,
+    START_DISCOVERY,
+    STOP_DISCOVERY
+  };
 
   struct RegisterArgs {
     RegisterArgs(
@@ -70,14 +85,40 @@ class BleAdvertisementSynchronizer {
     device::BluetoothAdvertisement::ErrorCallback error_callback;
   };
 
+  struct StartDiscoveryArgs {
+    StartDiscoveryArgs(
+        const device::BluetoothAdapter::DiscoverySessionCallback& callback,
+        const device::BluetoothAdapter::ErrorCallback& error_callback);
+    virtual ~StartDiscoveryArgs();
+
+    device::BluetoothAdapter::DiscoverySessionCallback callback;
+    device::BluetoothAdapter::ErrorCallback error_callback;
+  };
+
+  struct StopDiscoveryArgs {
+    StopDiscoveryArgs(
+        base::WeakPtr<device::BluetoothDiscoverySession> discovery_session,
+        const base::Closure& callback,
+        const device::BluetoothDiscoverySession::ErrorCallback& error_callback);
+    virtual ~StopDiscoveryArgs();
+
+    base::WeakPtr<device::BluetoothDiscoverySession> discovery_session;
+    base::Closure callback;
+    device::BluetoothDiscoverySession::ErrorCallback error_callback;
+  };
+
   struct Command {
     explicit Command(std::unique_ptr<RegisterArgs> register_args);
     explicit Command(std::unique_ptr<UnregisterArgs> unregister_args);
+    explicit Command(std::unique_ptr<StartDiscoveryArgs> start_discovery_args);
+    explicit Command(std::unique_ptr<StopDiscoveryArgs> stop_discovery_args);
     virtual ~Command();
 
     CommandType command_type;
     std::unique_ptr<RegisterArgs> register_args;
     std::unique_ptr<UnregisterArgs> unregister_args;
+    std::unique_ptr<StartDiscoveryArgs> start_discovery_args;
+    std::unique_ptr<StopDiscoveryArgs> stop_discovery_args;
   };
 
   virtual void ProcessQueue();
@@ -85,7 +126,7 @@ class BleAdvertisementSynchronizer {
   const std::deque<Command>& command_queue() { return command_queue_; }
 
  private:
-  friend class BleAdvertisementSynchronizerTest;
+  friend class BleSynchronizerTest;
 
   void SetTestDoubles(std::unique_ptr<base::Timer> test_timer,
                       std::unique_ptr<base::Clock> test_clock);
@@ -96,9 +137,9 @@ class BleAdvertisementSynchronizer {
   std::unique_ptr<base::Timer> timer_;
   std::unique_ptr<base::Clock> clock_;
   base::Time last_command_timestamp_;
-  base::WeakPtrFactory<BleAdvertisementSynchronizer> weak_ptr_factory_;
+  base::WeakPtrFactory<BleSynchronizer> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BleAdvertisementSynchronizer);
+  DISALLOW_COPY_AND_ASSIGN(BleSynchronizer);
 };
 
 }  // namespace tether

chromeos/components/tether/error_tolerant_ble_advertisement_impl.cc

@@ -8,8 +8,8 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
-#include "chromeos/components/tether/ble_advertisement_synchronizer.h"
 #include "chromeos/components/tether/ble_constants.h"
+#include "chromeos/components/tether/ble_synchronizer.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/proximity_auth/logging/logging.h"
 
@@ -32,12 +32,12 @@ std::unique_ptr<ErrorTolerantBleAdvertisement>
 ErrorTolerantBleAdvertisementImpl::Factory::NewInstance(
     const std::string& device_id,
     std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-    BleAdvertisementSynchronizer* ble_advertisement_synchronizer) {
+    BleSynchronizer* ble_synchronizer) {
   if (!factory_instance_)
     factory_instance_ = new Factory();
 
   return factory_instance_->BuildInstance(
-      device_id, std::move(advertisement_data), ble_advertisement_synchronizer);
+      device_id, std::move(advertisement_data), ble_synchronizer);
 }
 
 // static
@@ -50,9 +50,9 @@ std::unique_ptr<ErrorTolerantBleAdvertisement>
 ErrorTolerantBleAdvertisementImpl::Factory::BuildInstance(
     const std::string& device_id,
     std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-    BleAdvertisementSynchronizer* ble_advertisement_synchronizer) {
+    BleSynchronizer* ble_synchronizer) {
   return base::MakeUnique<ErrorTolerantBleAdvertisementImpl>(
-      device_id, std::move(advertisement_data), ble_advertisement_synchronizer);
+      device_id, std::move(advertisement_data), ble_synchronizer);
 }
 
 ErrorTolerantBleAdvertisementImpl::Factory::~Factory() {}
@@ -60,10 +60,10 @@ ErrorTolerantBleAdvertisementImpl::Factory::~Factory() {}
 ErrorTolerantBleAdvertisementImpl::ErrorTolerantBleAdvertisementImpl(
     const std::string& device_id,
     std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-    BleAdvertisementSynchronizer* ble_advertisement_synchronizer)
+    BleSynchronizer* ble_synchronizer)
     : ErrorTolerantBleAdvertisement(device_id),
       advertisement_data_(std::move(advertisement_data)),
-      ble_advertisement_synchronizer_(ble_advertisement_synchronizer),
+      ble_synchronizer_(ble_synchronizer),
       weak_ptr_factory_(this) {
   UpdateRegistrationStatus();
 }
@@ -124,7 +124,7 @@ void ErrorTolerantBleAdvertisementImpl::AttemptRegistration() {
   advertisement_data->set_service_uuids(CreateServiceUuids());
   advertisement_data->set_service_data(CreateServiceData());
 
-  ble_advertisement_synchronizer_->RegisterAdvertisement(
+  ble_synchronizer_->RegisterAdvertisement(
       std::move(advertisement_data),
       base::Bind(&ErrorTolerantBleAdvertisementImpl::OnAdvertisementRegistered,
                  weak_ptr_factory_.GetWeakPtr()),
@@ -145,7 +145,7 @@ void ErrorTolerantBleAdvertisementImpl::AttemptUnregistration() {
 
   unregistration_in_progress_ = true;
 
-  ble_advertisement_synchronizer_->UnregisterAdvertisement(
+  ble_synchronizer_->UnregisterAdvertisement(
       advertisement_,
       base::Bind(
           &ErrorTolerantBleAdvertisementImpl::OnAdvertisementUnregistered,

chromeos/components/tether/error_tolerant_ble_advertisement_impl.h

@@ -18,7 +18,7 @@ namespace chromeos {
 
 namespace tether {
 
-class BleAdvertisementSynchronizer;
+class BleSynchronizer;
 
 // Concrete ErrorTolerantBleAdvertisement implementation.
 class ErrorTolerantBleAdvertisementImpl
@@ -30,7 +30,7 @@ class ErrorTolerantBleAdvertisementImpl
     static std::unique_ptr<ErrorTolerantBleAdvertisement> NewInstance(
         const std::string& device_id,
         std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-        BleAdvertisementSynchronizer* ble_advertisement_synchronizer);
+        BleSynchronizer* ble_synchronizer);
 
     static void SetInstanceForTesting(Factory* factory);
 
@@ -38,7 +38,7 @@ class ErrorTolerantBleAdvertisementImpl
     virtual std::unique_ptr<ErrorTolerantBleAdvertisement> BuildInstance(
         const std::string& device_id,
         std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-        BleAdvertisementSynchronizer* ble_advertisement_synchronizer);
+        BleSynchronizer* ble_synchronizer);
 
     virtual ~Factory();
 
@@ -49,7 +49,7 @@ class ErrorTolerantBleAdvertisementImpl
   ErrorTolerantBleAdvertisementImpl(
       const std::string& device_id,
       std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data,
-      BleAdvertisementSynchronizer* ble_advertisement_synchronizer);
+      BleSynchronizer* ble_synchronizer);
   ~ErrorTolerantBleAdvertisementImpl() override;
 
   // ErrorTolerantBleAdvertisement:
@@ -88,7 +88,7 @@ class ErrorTolerantBleAdvertisementImpl
 
   std::string device_id_;
   std::unique_ptr<cryptauth::DataWithTimestamp> advertisement_data_;
-  BleAdvertisementSynchronizer* ble_advertisement_synchronizer_;
+  BleSynchronizer* ble_synchronizer_;
 
   bool registration_in_progress_ = false;
   bool unregistration_in_progress_ = false;

chromeos/components/tether/error_tolerant_ble_advertisement_impl_unittest.cc

@@ -8,7 +8,7 @@
 #include "base/callback_forward.h"
 #include "base/memory/ptr_util.h"
 #include "chromeos/components/tether/ble_constants.h"
-#include "chromeos/components/tether/fake_ble_advertisement_synchronizer.h"
+#include "chromeos/components/tether/fake_ble_synchronizer.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
 #include "device/bluetooth/test/mock_bluetooth_advertisement.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -38,7 +38,7 @@ class ErrorTolerantBleAdvertisementImplTest : public testing::Test {
     fake_advertisement_ = nullptr;
     stopped_callback_called_ = false;
 
-    fake_synchronizer_ = base::MakeUnique<FakeBleAdvertisementSynchronizer>();
+    fake_synchronizer_ = base::MakeUnique<FakeBleSynchronizer>();
 
     advertisement_ = base::MakeUnique<ErrorTolerantBleAdvertisementImpl>(
         kDeviceId,
@@ -110,7 +110,7 @@ class ErrorTolerantBleAdvertisementImplTest : public testing::Test {
 
   const std::unique_ptr<cryptauth::DataWithTimestamp> fake_advertisement_data_;
 
-  std::unique_ptr<FakeBleAdvertisementSynchronizer> fake_synchronizer_;
+  std::unique_ptr<FakeBleSynchronizer> fake_synchronizer_;
 
   device::MockBluetoothAdvertisement* fake_advertisement_;
 

chromeos/components/tether/fake_ble_advertisement_synchronizer.cc → chromeos/components/tether/fake_ble_synchronizer.cc

@@ -2,23 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chromeos/components/tether/fake_ble_advertisement_synchronizer.h"
+#include "chromeos/components/tether/fake_ble_synchronizer.h"
 
 namespace chromeos {
 
 namespace tether {
 
-FakeBleAdvertisementSynchronizer::FakeBleAdvertisementSynchronizer()
-    : BleAdvertisementSynchronizer(nullptr /* bluetooth_adapter */) {}
+FakeBleSynchronizer::FakeBleSynchronizer()
+    : BleSynchronizer(nullptr /* bluetooth_adapter */) {}
 
-FakeBleAdvertisementSynchronizer::~FakeBleAdvertisementSynchronizer() {}
+FakeBleSynchronizer::~FakeBleSynchronizer() {}
 
-size_t FakeBleAdvertisementSynchronizer::GetNumCommands() {
+size_t FakeBleSynchronizer::GetNumCommands() {
   return command_queue().size();
 }
 
-device::BluetoothAdvertisement::Data&
-FakeBleAdvertisementSynchronizer::GetAdvertisementData(size_t index) {
+device::BluetoothAdvertisement::Data& FakeBleSynchronizer::GetAdvertisementData(
+    size_t index) {
   DCHECK(command_queue().size() >= index);
   DCHECK(command_queue()[index].command_type ==
          CommandType::REGISTER_ADVERTISEMENT);
@@ -26,7 +26,7 @@ FakeBleAdvertisementSynchronizer::GetAdvertisementData(size_t index) {
 }
 
 const device::BluetoothAdapter::CreateAdvertisementCallback&
-FakeBleAdvertisementSynchronizer::GetRegisterCallback(size_t index) {
+FakeBleSynchronizer::GetRegisterCallback(size_t index) {
   DCHECK(command_queue().size() >= index);
   DCHECK(command_queue()[index].command_type ==
          CommandType::REGISTER_ADVERTISEMENT);
@@ -34,7 +34,7 @@ FakeBleAdvertisementSynchronizer::GetRegisterCallback(size_t index) {
 }
 
 const device::BluetoothAdapter::AdvertisementErrorCallback&
-FakeBleAdvertisementSynchronizer::GetRegisterErrorCallback(size_t index) {
+FakeBleSynchronizer::GetRegisterErrorCallback(size_t index) {
   DCHECK(command_queue().size() >= index);
   DCHECK(command_queue()[index].command_type ==
          CommandType::REGISTER_ADVERTISEMENT);
@@ -42,7 +42,7 @@ FakeBleAdvertisementSynchronizer::GetRegisterErrorCallback(size_t index) {
 }
 
 const device::BluetoothAdvertisement::SuccessCallback&
-FakeBleAdvertisementSynchronizer::GetUnregisterCallback(size_t index) {
+FakeBleSynchronizer::GetUnregisterCallback(size_t index) {
   DCHECK(command_queue().size() >= index);
   DCHECK(command_queue()[index].command_type ==
          CommandType::UNREGISTER_ADVERTISEMENT);
@@ -50,15 +50,43 @@ FakeBleAdvertisementSynchronizer::GetUnregisterCallback(size_t index) {
 }
 
 const device::BluetoothAdvertisement::ErrorCallback&
-FakeBleAdvertisementSynchronizer::GetUnregisterErrorCallback(size_t index) {
+FakeBleSynchronizer::GetUnregisterErrorCallback(size_t index) {
   DCHECK(command_queue().size() >= index);
   DCHECK(command_queue()[index].command_type ==
          CommandType::UNREGISTER_ADVERTISEMENT);
   return command_queue()[index].unregister_args->error_callback;
 }
 
+const device::BluetoothAdapter::DiscoverySessionCallback&
+FakeBleSynchronizer::GetStartDiscoveryCallback(size_t index) {
+  DCHECK(command_queue().size() >= index);
+  DCHECK(command_queue()[index].command_type == CommandType::START_DISCOVERY);
+  return command_queue()[index].start_discovery_args->callback;
+}
+
+const device::BluetoothAdapter::ErrorCallback&
+FakeBleSynchronizer::GetStartDiscoveryErrorCallback(size_t index) {
+  DCHECK(command_queue().size() >= index);
+  DCHECK(command_queue()[index].command_type == CommandType::START_DISCOVERY);
+  return command_queue()[index].start_discovery_args->error_callback;
+}
+
+const base::Closure& FakeBleSynchronizer::GetStopDiscoveryCallback(
+    size_t index) {
+  DCHECK(command_queue().size() >= index);
+  DCHECK(command_queue()[index].command_type == CommandType::STOP_DISCOVERY);
+  return command_queue()[index].stop_discovery_args->callback;
+}
+
+const device::BluetoothDiscoverySession::ErrorCallback&
+FakeBleSynchronizer::GetStopDiscoveryErrorCallback(size_t index) {
+  DCHECK(command_queue().size() >= index);
+  DCHECK(command_queue()[index].command_type == CommandType::STOP_DISCOVERY);
+  return command_queue()[index].stop_discovery_args->error_callback;
+}
+
 // Intentionally left blank. The fake should not actually issue any commands.
-void FakeBleAdvertisementSynchronizer::ProcessQueue() {}
+void FakeBleSynchronizer::ProcessQueue() {}
 
 }  // namespace tether
 

chromeos/components/tether/fake_ble_advertisement_synchronizer.h → chromeos/components/tether/fake_ble_synchronizer.h

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROMEOS_COMPONENTS_TETHER_FAKE_BLE_ADVERTISEMENT_SYNCHRONIZER_H_
-#define CHROMEOS_COMPONENTS_TETHER_FAKE_BLE_ADVERTISEMENT_SYNCHRONIZER_H_
+#ifndef CHROMEOS_COMPONENTS_TETHER_FAKE_BLE_SYNCHRONIZER_H_
+#define CHROMEOS_COMPONENTS_TETHER_FAKE_BLE_SYNCHRONIZER_H_
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
-#include "chromeos/components/tether/ble_advertisement_synchronizer.h"
+#include "chromeos/components/tether/ble_synchronizer.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
 
@@ -15,11 +15,11 @@ namespace chromeos {
 
 namespace tether {
 
-// Test double for BleAdvertisementSynchronizer.
-class FakeBleAdvertisementSynchronizer : public BleAdvertisementSynchronizer {
+// Test double for BleSynchronizer.
+class FakeBleSynchronizer : public BleSynchronizer {
  public:
-  FakeBleAdvertisementSynchronizer();
-  ~FakeBleAdvertisementSynchronizer() override;
+  FakeBleSynchronizer();
+  ~FakeBleSynchronizer() override;
 
   size_t GetNumCommands();
 
@@ -34,15 +34,25 @@ class FakeBleAdvertisementSynchronizer : public BleAdvertisementSynchronizer {
   const device::BluetoothAdvertisement::ErrorCallback&
   GetUnregisterErrorCallback(size_t index);
 
+  const device::BluetoothAdapter::DiscoverySessionCallback&
+  GetStartDiscoveryCallback(size_t index);
+  const device::BluetoothAdapter::ErrorCallback& GetStartDiscoveryErrorCallback(
+      size_t index);
+
+  const base::Closure& GetStopDiscoveryCallback(size_t index);
+  const device::BluetoothDiscoverySession::ErrorCallback&
+  GetStopDiscoveryErrorCallback(size_t index);
+
  protected:
+  // BleSynchronizer:
   void ProcessQueue() override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FakeBleAdvertisementSynchronizer);
+  DISALLOW_COPY_AND_ASSIGN(FakeBleSynchronizer);
 };
 
 }  // namespace tether
 
 }  // namespace chromeos
 
-#endif  // CHROMEOS_COMPONENTS_TETHER_FAKE_BLE_ADVERTISEMENT_SYNCHRONIZER_H_
+#endif  // CHROMEOS_COMPONENTS_TETHER_FAKE_BLE_SYNCHRONIZER_H_

chromeos/components/tether/initializer_impl.cc

@@ -8,8 +8,8 @@
 #include "chromeos/components/tether/active_host.h"
 #include "chromeos/components/tether/active_host_network_state_updater.h"
 #include "chromeos/components/tether/ble_advertisement_device_queue.h"
-#include "chromeos/components/tether/ble_advertisement_synchronizer.h"
 #include "chromeos/components/tether/ble_connection_manager.h"
+#include "chromeos/components/tether/ble_synchronizer.h"
 #include "chromeos/components/tether/crash_recovery_manager.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
 #include "chromeos/components/tether/disconnect_tethering_request_sender.h"
@@ -193,13 +193,12 @@ void InitializerImpl::CreateComponent() {
           cryptauth_service_->GetCryptAuthDeviceManager());
   ble_advertisement_device_queue_ =
       base::MakeUnique<BleAdvertisementDeviceQueue>();
-  ble_advertisement_synchronizer_ =
-      base::MakeUnique<BleAdvertisementSynchronizer>(adapter_);
+  ble_synchronizer_ = base::MakeUnique<BleSynchronizer>(adapter_);
   ble_advertiser_ = base::MakeUnique<BleAdvertiser>(
       local_device_data_provider_.get(), remote_beacon_seed_fetcher_.get(),
-      ble_advertisement_synchronizer_.get());
-  ble_scanner_ =
-      base::MakeUnique<BleScanner>(adapter_, local_device_data_provider_.get());
+      ble_synchronizer_.get());
+  ble_scanner_ = base::MakeUnique<BleScanner>(
+      adapter_, local_device_data_provider_.get(), ble_synchronizer_.get());
   ble_connection_manager_ = base::MakeUnique<BleConnectionManager>(
       cryptauth_service_, adapter_, ble_advertisement_device_queue_.get(),
       ble_advertiser_.get(), ble_scanner_.get());
@@ -373,7 +372,7 @@ void InitializerImpl::FinishAsynchronousShutdownIfPossible() {
   ble_connection_manager_.reset();
   ble_scanner_.reset();
   ble_advertiser_.reset();
-  ble_advertisement_synchronizer_.reset();
+  ble_synchronizer_.reset();
   ble_advertisement_device_queue_.reset();
   remote_beacon_seed_fetcher_.reset();
   local_device_data_provider_.reset();

chromeos/components/tether/initializer_impl.h

@@ -40,8 +40,8 @@ namespace tether {
 class ActiveHost;
 class ActiveHostNetworkStateUpdater;
 class BleAdvertisementDeviceQueue;
-class BleAdvertisementSynchronizer;
 class BleConnectionManager;
+class BleSynchronizer;
 class CrashRecoveryManager;
 class NetworkConnectionHandlerTetherDelegate;
 class DeviceIdTetherNetworkGuidMap;
@@ -156,7 +156,7 @@ class InitializerImpl : public Initializer,
   std::unique_ptr<cryptauth::RemoteBeaconSeedFetcher>
       remote_beacon_seed_fetcher_;
   std::unique_ptr<BleAdvertisementDeviceQueue> ble_advertisement_device_queue_;
-  std::unique_ptr<BleAdvertisementSynchronizer> ble_advertisement_synchronizer_;
+  std::unique_ptr<BleSynchronizer> ble_synchronizer_;
   std::unique_ptr<BleAdvertiser> ble_advertiser_;
   std::unique_ptr<BleScanner> ble_scanner_;
   std::unique_ptr<BleConnectionManager> ble_connection_manager_;