[CrOS Tether] Sort Tether network lists.

chromeos/components/tether/host_scanner_operation_unittest.cc

 // Copyright 2016 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/host_scanner_operation.h"
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
+#include "chromeos/components/tether/host_scan_device_prioritizer.h"
 #include "chromeos/components/tether/message_wrapper.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/proto/tether.pb.h"
 #include "chromeos/components/tether/proto_test_util.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::StrictMock;
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 const char kDefaultCarrier[] = "Google Fi";
 
-class TestHostScanDevicePrioritizer : public MockHostScanDevicePrioritizer {
+class TestHostScanDevicePrioritizer : public HostScanDevicePrioritizer {
  public:
-  TestHostScanDevicePrioritizer() : MockHostScanDevicePrioritizer() {}
+  TestHostScanDevicePrioritizer() : HostScanDevicePrioritizer() {}
   ~TestHostScanDevicePrioritizer() override {}
 
-  // Simply reverses the device order.
+  // HostScanDevicePrioritizer:
   void SortByHostScanOrder(
       std::vector<cryptauth::RemoteDevice>* remote_devices) const override {
+    // Simply reverses the device order.
     for (size_t i = 0; i < remote_devices->size() / 2; ++i) {
       std::iter_swap(remote_devices->begin() + i,
                      remote_devices->end() - i - 1);
     }
   }
 
   void VerifyHasBeenPrioritized(
       const std::vector<cryptauth::RemoteDevice>& original,
       const std::vector<cryptauth::RemoteDevice>& prioritized) {
     std::vector<cryptauth::RemoteDevice> copy_of_original = original;
@@ skipping 50 matching lines @@
             CreateTetherAvailabilityRequestString()),
         test_devices_(cryptauth::GenerateTestRemoteDevices(5)) {
     // These tests are written under the assumption that there are a maximum of
     // 3 connection attempts; they need to be edited if this value changes.
     EXPECT_EQ(3u, MessageTransferOperation::kMaxConnectionAttemptsPerDevice);
   }
 
   void SetUp() override {
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
     test_host_scan_device_prioritizer_ =
-        base::MakeUnique<StrictMock<TestHostScanDevicePrioritizer>>();
+        base::MakeUnique<TestHostScanDevicePrioritizer>();
     mock_tether_host_response_recorder_ =
         base::MakeUnique<StrictMock<MockTetherHostResponseRecorder>>();
     test_observer_ = base::WrapUnique(new TestObserver());
   }
 
   void ConstructOperation(
       const std::vector<cryptauth::RemoteDevice>& remote_devices) {
     operation_ = base::WrapUnique(new HostScannerOperation(
         remote_devices, fake_ble_connection_manager_.get(),
         test_host_scan_device_prioritizer_.get(),
@@ skipping 74 matching lines @@
     ConstructOperation(std::vector<cryptauth::RemoteDevice>{test_devices_[0]});
     SimulateDeviceAuthenticationAndVerifyMessageSent(test_devices_[0], 1u);
     SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
         test_devices_[0], response_code, std::string(kDefaultCarrier), true);
   }
 
   const std::string tether_availability_request_string_;
   const std::vector<cryptauth::RemoteDevice> test_devices_;
 
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
-  std::unique_ptr<StrictMock<TestHostScanDevicePrioritizer>>
+  std::unique_ptr<TestHostScanDevicePrioritizer>
       test_host_scan_device_prioritizer_;
   std::unique_ptr<StrictMock<MockTetherHostResponseRecorder>>
       mock_tether_host_response_recorder_;
   std::unique_ptr<TestObserver> test_observer_;
   std::unique_ptr<HostScannerOperation> operation_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HostScannerOperationTest);
 };
 
@@ skipping 142 matching lines @@
       "noService", true /* expected_to_be_last_scan_result */);
 
   // The scan should be over, and still no new scan results should have come in.
   EXPECT_TRUE(test_observer_->has_final_scan_result_been_sent);
   EXPECT_EQ(2u, test_observer_->scanned_devices_so_far.size());
 }
 
 }  // namespace tether
 
 }  // namespace chromeos