Rename BleAdapterPowerManager to BleAdapterManager

This prepares for https://crrev.com/c/1239621

Bug: 877344
Change-Id: Id857841551cf659c14747da36f91b9e848ae9c3e
Reviewed-on: https://chromium-review.googlesource.com/c/1247142
Commit-Queue: Jun Choi <hongjunchoi@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#596024}

device/BUILD.gn

@@ -75,7 +75,7 @@ test("device_unittests") {
     "fido/ble/fido_ble_frames_unittest.cc",
     "fido/ble/fido_ble_pairing_delegate_unittest.cc",
     "fido/ble/fido_ble_transaction_unittest.cc",
-    "fido/ble_adapter_power_manager_unittest.cc",
+    "fido/ble_adapter_manager_unittest.cc",
     "fido/cable/fido_cable_device_unittest.cc",
     "fido/cable/fido_cable_discovery_unittest.cc",
     "fido/cable/fido_cable_handshake_handler_unittest.cc",

device/fido/BUILD.gn

@@ -43,8 +43,8 @@ component("fido") {
     "ble/fido_ble_transaction.h",
     "ble/fido_ble_uuids.cc",
     "ble/fido_ble_uuids.h",
-    "ble_adapter_power_manager.cc",
-    "ble_adapter_power_manager.h",
+    "ble_adapter_manager.cc",
+    "ble_adapter_manager.h",
     "cable/cable_discovery_data.h",
     "cable/fido_cable_device.cc",
     "cable/fido_cable_device.h",

device/fido/ble_adapter_power_manager.cc → device/fido/ble_adapter_manager.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "device/fido/ble_adapter_power_manager.h"
+#include "device/fido/ble_adapter_manager.h"
 
 #include <utility>
 
@@ -11,14 +11,13 @@
 
 namespace device {
 
-BleAdapterPowerManager::BleAdapterPowerManager(
-    FidoRequestHandlerBase* request_handler)
+BleAdapterManager::BleAdapterManager(FidoRequestHandlerBase* request_handler)
     : request_handler_(request_handler), weak_factory_(this) {
   BluetoothAdapterFactory::Get().GetAdapter(base::BindRepeating(
-      &BleAdapterPowerManager::Start, weak_factory_.GetWeakPtr()));
+      &BleAdapterManager::Start, weak_factory_.GetWeakPtr()));
 }
 
-BleAdapterPowerManager::~BleAdapterPowerManager() {
+BleAdapterManager::~BleAdapterManager() {
   if (adapter_powered_on_programmatically_)
     SetAdapterPower(false /* set_power_on */);
 
@@ -26,19 +25,19 @@ BleAdapterPowerManager::~BleAdapterPowerManager() {
     adapter_->RemoveObserver(this);
 }
 
-void BleAdapterPowerManager::SetAdapterPower(bool set_power_on) {
+void BleAdapterManager::SetAdapterPower(bool set_power_on) {
   if (set_power_on)
     adapter_powered_on_programmatically_ = true;
 
   adapter_->SetPowered(set_power_on, base::DoNothing(), base::DoNothing());
 }
 
-void BleAdapterPowerManager::AdapterPoweredChanged(BluetoothAdapter* adapter,
-                                                   bool powered) {
+void BleAdapterManager::AdapterPoweredChanged(BluetoothAdapter* adapter,
+                                              bool powered) {
   request_handler_->OnBluetoothAdapterPowerChanged(powered);
 }
 
-void BleAdapterPowerManager::Start(scoped_refptr<BluetoothAdapter> adapter) {
+void BleAdapterManager::Start(scoped_refptr<BluetoothAdapter> adapter) {
   DCHECK(!adapter_);
   adapter_ = std::move(adapter);
   DCHECK(adapter_);

device/fido/ble_adapter_power_manager.h → device/fido/ble_adapter_manager.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef DEVICE_FIDO_BLE_ADAPTER_POWER_MANAGER_H_
-#define DEVICE_FIDO_BLE_ADAPTER_POWER_MANAGER_H_
+#ifndef DEVICE_FIDO_BLE_ADAPTER_MANAGER_H_
+#define DEVICE_FIDO_BLE_ADAPTER_MANAGER_H_
 
 #include "base/component_export.h"
 #include "base/macros.h"
@@ -14,7 +14,7 @@
 
 namespace device {
 
-class COMPONENT_EXPORT(DEVICE_FIDO) BleAdapterPowerManager
+class COMPONENT_EXPORT(DEVICE_FIDO) BleAdapterManager
     : public BluetoothAdapter::Observer {
  public:
   // Handles notifying |request_handler| when BluetoothAdapter is powered on and
@@ -22,13 +22,13 @@ class COMPONENT_EXPORT(DEVICE_FIDO) BleAdapterPowerManager
   // programmatically, and if BluetoothAdapter was powered on programmatically,
   // powers off BluetoothAdapter when |this| goes out of scope.
   // |request_handler| must outlive |this|.
-  BleAdapterPowerManager(FidoRequestHandlerBase* request_handler);
-  ~BleAdapterPowerManager() override;
+  BleAdapterManager(FidoRequestHandlerBase* request_handler);
+  ~BleAdapterManager() override;
 
   void SetAdapterPower(bool set_power_on);
 
  private:
-  friend class FidoBleAdapterPowerManagerTest;
+  friend class FidoBleAdapterManagerTest;
 
   // BluetoothAdapter::Observer:
   void AdapterPoweredChanged(BluetoothAdapter* adapter, bool powered) override;
@@ -39,11 +39,11 @@ class COMPONENT_EXPORT(DEVICE_FIDO) BleAdapterPowerManager
   scoped_refptr<BluetoothAdapter> adapter_;
   bool adapter_powered_on_programmatically_ = false;
 
-  base::WeakPtrFactory<BleAdapterPowerManager> weak_factory_;
+  base::WeakPtrFactory<BleAdapterManager> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BleAdapterPowerManager);
+  DISALLOW_COPY_AND_ASSIGN(BleAdapterManager);
 };
 
 }  // namespace device
 
-#endif  // DEVICE_FIDO_BLE_ADAPTER_POWER_MANAGER_H_
+#endif  // DEVICE_FIDO_BLE_ADAPTER_MANAGER_H_

device/fido/ble_adapter_power_manager_unittest.cc → device/fido/ble_adapter_manager_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "device/fido/ble_adapter_power_manager.h"
+#include "device/fido/ble_adapter_manager.h"
 
 #include <memory>
 
@@ -57,22 +57,21 @@ class FakeFidoRequestHandlerBase : public FidoRequestHandlerBase {
 
 }  // namespace
 
-class FidoBleAdapterPowerManagerTest : public ::testing::Test {
+class FidoBleAdapterManagerTest : public ::testing::Test {
  public:
-  FidoBleAdapterPowerManagerTest() {
+  FidoBleAdapterManagerTest() {
     BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
   }
 
-  std::unique_ptr<BleAdapterPowerManager> CreateTestBleAdapterPowerManager() {
-    return std::make_unique<BleAdapterPowerManager>(
-        fake_request_handler_.get());
+  std::unique_ptr<BleAdapterManager> CreateTestBleAdapterManager() {
+    return std::make_unique<BleAdapterManager>(fake_request_handler_.get());
   }
 
   MockBluetoothAdapter* adapter() { return adapter_.get(); }
   MockTransportAvailabilityObserver* observer() { return mock_observer_.get(); }
   bool adapter_powered_on_programmatically(
-      const BleAdapterPowerManager& adapter_power_manager) {
-    return adapter_power_manager.adapter_powered_on_programmatically_;
+      const BleAdapterManager& adapter_manager) {
+    return adapter_manager.adapter_powered_on_programmatically_;
   }
 
  protected:
@@ -85,7 +84,7 @@ class FidoBleAdapterPowerManagerTest : public ::testing::Test {
       std::make_unique<FakeFidoRequestHandlerBase>(mock_observer_.get());
 };
 
-TEST_F(FidoBleAdapterPowerManagerTest, AdapaterNotPresent) {
+TEST_F(FidoBleAdapterManagerTest, AdapaterNotPresent) {
   EXPECT_CALL(*adapter(), IsPresent()).WillOnce(::testing::Return(false));
   EXPECT_CALL(*adapter(), IsPowered()).WillOnce(::testing::Return(false));
   EXPECT_CALL(*adapter(), CanPower()).WillOnce(::testing::Return(false));
@@ -94,14 +93,14 @@ TEST_F(FidoBleAdapterPowerManagerTest, AdapaterNotPresent) {
   EXPECT_CALL(*observer(), OnTransportAvailabilityEnumerated(_))
       .WillOnce(::testing::SaveArg<0>(&data));
 
-  CreateTestBleAdapterPowerManager();
+  CreateTestBleAdapterManager();
   scoped_task_environment_.RunUntilIdle();
 
   EXPECT_FALSE(data.is_ble_powered);
   EXPECT_FALSE(data.can_power_on_ble_adapter);
 }
 
-TEST_F(FidoBleAdapterPowerManagerTest, AdapaterPresentAndPowered) {
+TEST_F(FidoBleAdapterManagerTest, AdapaterPresentAndPowered) {
   EXPECT_CALL(*adapter(), IsPresent()).WillOnce(::testing::Return(true));
   EXPECT_CALL(*adapter(), IsPowered()).WillOnce(::testing::Return(true));
   EXPECT_CALL(*adapter(), CanPower()).WillOnce(::testing::Return(false));
@@ -110,14 +109,14 @@ TEST_F(FidoBleAdapterPowerManagerTest, AdapaterPresentAndPowered) {
   EXPECT_CALL(*observer(), OnTransportAvailabilityEnumerated(_))
       .WillOnce(::testing::SaveArg<0>(&data));
 
-  CreateTestBleAdapterPowerManager();
+  CreateTestBleAdapterManager();
   scoped_task_environment_.RunUntilIdle();
 
   EXPECT_TRUE(data.is_ble_powered);
   EXPECT_FALSE(data.can_power_on_ble_adapter);
 }
 
-TEST_F(FidoBleAdapterPowerManagerTest, AdapaterPresentAndCanBePowered) {
+TEST_F(FidoBleAdapterManagerTest, AdapaterPresentAndCanBePowered) {
   EXPECT_CALL(*adapter(), IsPresent()).WillOnce(::testing::Return(true));
   EXPECT_CALL(*adapter(), IsPowered()).WillOnce(::testing::Return(false));
   EXPECT_CALL(*adapter(), CanPower()).WillOnce(::testing::Return(true));
@@ -126,15 +125,15 @@ TEST_F(FidoBleAdapterPowerManagerTest, AdapaterPresentAndCanBePowered) {
   EXPECT_CALL(*observer(), OnTransportAvailabilityEnumerated(_))
       .WillOnce(::testing::SaveArg<0>(&data));
 
-  CreateTestBleAdapterPowerManager();
+  CreateTestBleAdapterManager();
   scoped_task_environment_.RunUntilIdle();
 
   EXPECT_FALSE(data.is_ble_powered);
   EXPECT_TRUE(data.can_power_on_ble_adapter);
 }
 
-TEST_F(FidoBleAdapterPowerManagerTest, TestSetBluetoothPowerOn) {
-  auto power_manager = CreateTestBleAdapterPowerManager();
+TEST_F(FidoBleAdapterManagerTest, TestSetBluetoothPowerOn) {
+  auto power_manager = CreateTestBleAdapterManager();
   ::testing::InSequence s;
   EXPECT_CALL(*adapter(), SetPowered(true, _, _));
   EXPECT_CALL(*adapter(), SetPowered(false, _, _));

device/fido/fido_request_handler_base.cc

@@ -13,7 +13,7 @@
 #include "base/strings/string_piece.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "build/build_config.h"
-#include "device/fido/ble_adapter_power_manager.h"
+#include "device/fido/ble_adapter_manager.h"
 #include "device/fido/fido_device.h"
 #include "device/fido/fido_task.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -168,10 +168,10 @@ void FidoRequestHandlerBase::OnBluetoothAdapterPowerChanged(
 }
 
 void FidoRequestHandlerBase::PowerOnBluetoothAdapter() {
-  if (!bluetooth_power_manager_)
+  if (!bluetooth_adapter_manager_)
     return;
 
-  bluetooth_power_manager_->SetAdapterPower(true /* set_power_on */);
+  bluetooth_adapter_manager_->SetAdapterPower(true /* set_power_on */);
 }
 
 base::WeakPtr<FidoRequestHandlerBase> FidoRequestHandlerBase::GetWeakPtr() {
@@ -287,7 +287,7 @@ void FidoRequestHandlerBase::InitializeAuthenticatorAndDispatchRequest(
 }
 
 void FidoRequestHandlerBase::ConstructBleAdapterPowerManager() {
-  bluetooth_power_manager_ = std::make_unique<BleAdapterPowerManager>(this);
+  bluetooth_adapter_manager_ = std::make_unique<BleAdapterManager>(this);
 }
 
 }  // namespace device

device/fido/fido_request_handler_base.h

@@ -29,7 +29,7 @@ class Connector;
 
 namespace device {
 
-class BleAdapterPowerManager;
+class BleAdapterManager;
 class FidoAuthenticator;
 class FidoDevice;
 class FidoTask;
@@ -208,7 +208,7 @@ class COMPONENT_EXPORT(DEVICE_FIDO) FidoRequestHandlerBase
   TransportAvailabilityObserver* observer_ = nullptr;
   TransportAvailabilityInfo transport_availability_info_;
   base::RepeatingClosure notify_observer_callback_;
-  std::unique_ptr<BleAdapterPowerManager> bluetooth_power_manager_;
+  std::unique_ptr<BleAdapterManager> bluetooth_adapter_manager_;
 
   base::WeakPtrFactory<FidoRequestHandlerBase> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(FidoRequestHandlerBase);