[CrOS Tether] Create TetherHostResponseRecorder, which records ConnectTetheringResponses and Tether…

chromeos/components/tether/tether_connector_unittest.cc

 // Copyright 2017 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 "chromeos/components/tether/tether_connector.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "chromeos/components/tether/connect_tethering_operation.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
 #include "chromeos/components/tether/fake_active_host.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
 #include "chromeos/components/tether/fake_tether_host_fetcher.h"
 #include "chromeos/components/tether/fake_wifi_hotspot_connector.h"
-#include "chromeos/components/tether/mock_host_scan_device_prioritizer.h"
+#include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/components/tether/tether_connector.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_test.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 34 matching lines @@
     InitiateTetherNetworkConnection(tether_network_guid, success_callback,
                                     error_callback);
   }
 };
 
 class FakeConnectTetheringOperation : public ConnectTetheringOperation {
  public:
   FakeConnectTetheringOperation(
       const cryptauth::RemoteDevice& device_to_connect,
       BleConnectionManager* connection_manager,
-      HostScanDevicePrioritizer* host_scan_device_prioritizer)
+      TetherHostResponseRecorder* tether_host_response_recorder)
       : ConnectTetheringOperation(device_to_connect,
                                   connection_manager,
-                                  host_scan_device_prioritizer) {}
+                                  tether_host_response_recorder) {}
 
   ~FakeConnectTetheringOperation() override {}
 
   void SendSuccessfulResponse(const std::string& ssid,
                               const std::string& password) {
     NotifyObserversOfSuccessfulResponse(ssid, password);
   }
 
   void SendFailedResponse(ConnectTetheringResponse_ResponseCode error_code) {
     NotifyObserversOfConnectionFailure(error_code);
@@ skipping 13 matching lines @@
 
   std::vector<FakeConnectTetheringOperation*>& created_operations() {
     return created_operations_;
   }
 
  protected:
   // ConnectTetheringOperation::Factory:
   std::unique_ptr<ConnectTetheringOperation> BuildInstance(
       const cryptauth::RemoteDevice& device_to_connect,
       BleConnectionManager* connection_manager,
-      HostScanDevicePrioritizer* host_scan_device_prioritizer) override {
+      TetherHostResponseRecorder* tether_host_response_recorder) override {
     FakeConnectTetheringOperation* operation =
         new FakeConnectTetheringOperation(device_to_connect, connection_manager,
-                                          host_scan_device_prioritizer);
+                                          tether_host_response_recorder);
     created_operations_.push_back(operation);
     return base::WrapUnique(operation);
   }
 
  private:
   std::vector<FakeConnectTetheringOperation*> created_operations_;
 };
 
 }  // namespace
 
@@ skipping 15 matching lines @@
         fake_operation_factory_.get());
 
     test_network_connection_handler_ =
         base::WrapUnique(new TestNetworkConnectionHandler());
     fake_wifi_hotspot_connector_ =
         base::MakeUnique<FakeWifiHotspotConnector>(network_state_handler());
     fake_active_host_ = base::MakeUnique<FakeActiveHost>();
     fake_tether_host_fetcher_ = base::MakeUnique<FakeTetherHostFetcher>(
         test_devices_, false /* synchronously_reply_with_results */);
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
-    mock_host_scan_device_prioritizer_ =
-        base::MakeUnique<MockHostScanDevicePrioritizer>();
+    mock_tether_host_response_recorder_ =
+        base::MakeUnique<MockTetherHostResponseRecorder>();
     device_id_tether_network_guid_map_ =
         base::MakeUnique<DeviceIdTetherNetworkGuidMap>();
 
     result_.clear();
 
     tether_connector_ = base::WrapUnique(new TetherConnector(
         test_network_connection_handler_.get(), network_state_handler(),
         fake_wifi_hotspot_connector_.get(), fake_active_host_.get(),
         fake_tether_host_fetcher_.get(), fake_ble_connection_manager_.get(),
-        mock_host_scan_device_prioritizer_.get(),
+        mock_tether_host_response_recorder_.get(),
         device_id_tether_network_guid_map_.get()));
 
     SetUpTetherNetworks();
   }
 
   void TearDown() override {
     // Must delete |fake_wifi_hotspot_connector_| before NetworkStateHandler is
     // destroyed to ensure that NetworkStateHandler has zero observers by the
     // time it reaches its destructor.
     fake_wifi_hotspot_connector_.reset();
@@ skipping 65 matching lines @@
   const std::vector<cryptauth::RemoteDevice> test_devices_;
   const base::MessageLoop message_loop_;
 
   std::unique_ptr<FakeConnectTetheringOperationFactory> fake_operation_factory_;
   std::unique_ptr<TestNetworkConnectionHandler>
       test_network_connection_handler_;
   std::unique_ptr<FakeWifiHotspotConnector> fake_wifi_hotspot_connector_;
   std::unique_ptr<FakeActiveHost> fake_active_host_;
   std::unique_ptr<FakeTetherHostFetcher> fake_tether_host_fetcher_;
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
-  std::unique_ptr<MockHostScanDevicePrioritizer>
-      mock_host_scan_device_prioritizer_;
+  std::unique_ptr<MockTetherHostResponseRecorder>
+      mock_tether_host_response_recorder_;
   // TODO(hansberry): Use a fake for this when a real mapping scheme is created.
   std::unique_ptr<DeviceIdTetherNetworkGuidMap>
       device_id_tether_network_guid_map_;
 
   std::string result_;
 
   std::unique_ptr<TetherConnector> tether_connector_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TetherConnectorTest);
@@ skipping 221 matching lines @@
   EXPECT_EQ(test_devices_[1].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 }
 
 }  // namespace tether
 
 }  // namespace chromeos