[CrOS Tether] Fix miscellaneous issues with HostScanScheduler.

chromeos/components/tether/host_scan_scheduler_unittest.cc

Index: chromeos/components/tether/host_scan_scheduler_unittest.cc
diff --git a/chromeos/components/tether/host_scan_scheduler_unittest.cc b/chromeos/components/tether/host_scan_scheduler_unittest.cc
index ebf7a61b5580dfad44d41ba60563df73300ead06..fedc571842bf6bdd05b6ab36b7809f25a5ca8b24 100644
--- a/chromeos/components/tether/host_scan_scheduler_unittest.cc
+++ b/chromeos/components/tether/host_scan_scheduler_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -23,9 +23,9 @@ namespace {}  // namespace
 
 class HostScanSchedulerTest : public testing::Test {
  protected:
-  class TestContext : public HostScanScheduler::Context {
+  class TestDelegate : public HostScanScheduler::Delegate {
    public:
-    TestContext(HostScanSchedulerTest* test)
+    TestDelegate(HostScanSchedulerTest* test)
         : test_(test),
           observer_(nullptr),
           is_authenticated_user_logged_in(true),
@@ -60,15 +60,17 @@ class HostScanSchedulerTest : public testing::Test {
              observer_ == test_->host_scan_scheduler_.get();
     }
 
-    void SetIsAuthenticatedUserLoggedIn(bool value) {
+    void set_is_authenticated_user_logged_in(bool value) {
       is_authenticated_user_logged_in = value;
     }
 
-    void SetIsNetworkConnectedOrConnecting(bool value) {
+    void set_is_network_connected_or_connecting(bool value) {
       is_network_connected_or_connecting = value;
     }
 
-    void AreTetherHostsSynced(bool value) { are_tether_hosts_synced = value; }
+    void set_are_tether_hosts_synced(bool value) {
+      are_tether_hosts_synced = value;
+    }
 
    private:
     const HostScanSchedulerTest* test_;
@@ -79,10 +81,10 @@ class HostScanSchedulerTest : public testing::Test {
     bool are_tether_hosts_synced;
   };
 
-  class MockHostScanner : public HostScanner {
+  class FakeHostScanner : public HostScanner {
    public:
-    MockHostScanner() : num_scans_started_(0) {}
-    ~MockHostScanner() override {}
+    FakeHostScanner() : num_scans_started_(0) {}
+    ~FakeHostScanner() override {}
 
     void StartScan() override { num_scans_started_++; }
 
@@ -95,19 +97,20 @@ class HostScanSchedulerTest : public testing::Test {
   HostScanSchedulerTest() {}
 
   void SetUp() override {
-    test_context_ = new TestContext(this);
-    mock_host_scanner_ = new MockHostScanner();
+    test_delegate_ = new TestDelegate(this);
+    fake_host_scanner_ = new FakeHostScanner();
 
-    host_scan_scheduler_.reset(new HostScanScheduler(
-        base::WrapUnique(test_context_), base::WrapUnique(mock_host_scanner_)));
+    host_scan_scheduler_.reset(
+        new HostScanScheduler(base::WrapUnique(test_delegate_),
+                              base::WrapUnique(fake_host_scanner_)));
 
-    EXPECT_FALSE(test_context_->IsObserverSet());
+    EXPECT_FALSE(test_delegate_->IsObserverSet());
     host_scan_scheduler_->InitializeAutomaticScans();
-    EXPECT_TRUE(test_context_->IsObserverSet());
+    EXPECT_TRUE(test_delegate_->IsObserverSet());
   }
 
   void TearDown() override {
-    EXPECT_TRUE(test_context_->IsObserverSet());
+    EXPECT_TRUE(test_delegate_->IsObserverSet());
     host_scan_scheduler_.reset();
   }
 
@@ -115,19 +118,19 @@ class HostScanSchedulerTest : public testing::Test {
                                      bool is_network_connected_or_connecting,
                                      bool are_tether_hosts_synced,
                                      int num_expected_scans) {
-    test_context_->SetIsAuthenticatedUserLoggedIn(
+    test_delegate_->set_is_authenticated_user_logged_in(
         is_authenticated_user_logged_in);
-    test_context_->SetIsNetworkConnectedOrConnecting(
+    test_delegate_->set_is_network_connected_or_connecting(
         is_network_connected_or_connecting);
-    test_context_->AreTetherHostsSynced(are_tether_hosts_synced);
+    test_delegate_->set_are_tether_hosts_synced(are_tether_hosts_synced);
     host_scan_scheduler_->ScheduleScanNowIfPossible();
-    EXPECT_EQ(num_expected_scans, mock_host_scanner_->num_scans_started());
+    EXPECT_EQ(num_expected_scans, fake_host_scanner_->num_scans_started());
   }
 
   std::unique_ptr<HostScanScheduler> host_scan_scheduler_;
 
-  TestContext* test_context_;
-  MockHostScanner* mock_host_scanner_;
+  TestDelegate* test_delegate_;
+  FakeHostScanner* fake_host_scanner_;
 };
 
 TEST_F(HostScanSchedulerTest, TestObserverAddedAndRemoved) {
@@ -136,7 +139,7 @@ TEST_F(HostScanSchedulerTest, TestObserverAddedAndRemoved) {
 }
 
 TEST_F(HostScanSchedulerTest, TestScheduleScanNowIfPossible) {
-  EXPECT_EQ(0, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(0, fake_host_scanner_->num_scans_started());
 
   // A scan should only be started when an authenticated user is logged in,
   // the network is not connected/connecting, and tether hosts are synced.
@@ -151,75 +154,75 @@ TEST_F(HostScanSchedulerTest, TestScheduleScanNowIfPossible) {
 }
 
 TEST_F(HostScanSchedulerTest, TestLoggedInStateChange) {
-  EXPECT_EQ(0, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(0, fake_host_scanner_->num_scans_started());
 
-  test_context_->SetIsAuthenticatedUserLoggedIn(true);
-  test_context_->SetIsNetworkConnectedOrConnecting(false);
-  test_context_->AreTetherHostsSynced(true);
+  test_delegate_->set_is_authenticated_user_logged_in(true);
+  test_delegate_->set_is_network_connected_or_connecting(false);
+  test_delegate_->set_are_tether_hosts_synced(true);
 
   host_scan_scheduler_->LoggedInStateChanged();
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 
   // Change a condition so that it should not scan, and re-trigger; there should
   // still be only 1 started scan.
-  test_context_->SetIsAuthenticatedUserLoggedIn(false);
+  test_delegate_->set_is_authenticated_user_logged_in(false);
   host_scan_scheduler_->LoggedInStateChanged();
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 }
 
 TEST_F(HostScanSchedulerTest, TestSuspendDone) {
-  EXPECT_EQ(0, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(0, fake_host_scanner_->num_scans_started());
 
-  test_context_->SetIsAuthenticatedUserLoggedIn(true);
-  test_context_->SetIsNetworkConnectedOrConnecting(false);
-  test_context_->AreTetherHostsSynced(true);
+  test_delegate_->set_is_authenticated_user_logged_in(true);
+  test_delegate_->set_is_network_connected_or_connecting(false);
+  test_delegate_->set_are_tether_hosts_synced(true);
 
   host_scan_scheduler_->SuspendDone(base::TimeDelta::FromSeconds(1));
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 
   // Change a condition so that it should not scan, and re-trigger; there should
   // still be only 1 started scan.
-  test_context_->SetIsAuthenticatedUserLoggedIn(false);
+  test_delegate_->set_is_authenticated_user_logged_in(false);
   host_scan_scheduler_->SuspendDone(base::TimeDelta::FromSeconds(1));
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 }
 
 TEST_F(HostScanSchedulerTest, TestNetworkConnectionStateChanged) {
-  EXPECT_EQ(0, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(0, fake_host_scanner_->num_scans_started());
 
-  test_context_->SetIsAuthenticatedUserLoggedIn(true);
-  test_context_->SetIsNetworkConnectedOrConnecting(false);
-  test_context_->AreTetherHostsSynced(true);
+  test_delegate_->set_is_authenticated_user_logged_in(true);
+  test_delegate_->set_is_network_connected_or_connecting(false);
+  test_delegate_->set_are_tether_hosts_synced(true);
 
   host_scan_scheduler_->NetworkConnectionStateChanged(nullptr);
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 
   // Change a condition so that it should not scan, and re-trigger; there should
   // still be only 1 started scan.
-  test_context_->SetIsNetworkConnectedOrConnecting(true);
+  test_delegate_->set_is_network_connected_or_connecting(true);
   host_scan_scheduler_->NetworkConnectionStateChanged(nullptr);
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 }
 
 TEST_F(HostScanSchedulerTest, TestOnSyncFinished) {
-  EXPECT_EQ(0, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(0, fake_host_scanner_->num_scans_started());
 
-  test_context_->SetIsAuthenticatedUserLoggedIn(true);
-  test_context_->SetIsNetworkConnectedOrConnecting(false);
-  test_context_->AreTetherHostsSynced(true);
+  test_delegate_->set_is_authenticated_user_logged_in(true);
+  test_delegate_->set_is_network_connected_or_connecting(false);
+  test_delegate_->set_are_tether_hosts_synced(true);
 
   host_scan_scheduler_->OnSyncFinished(
       cryptauth::CryptAuthDeviceManager::SyncResult::SUCCESS,
       cryptauth::CryptAuthDeviceManager::DeviceChangeResult::CHANGED);
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 
   // Change a condition so that it should not scan, and re-trigger; there should
   // still be only 1 started scan.
-  test_context_->AreTetherHostsSynced(false);
+  test_delegate_->set_are_tether_hosts_synced(false);
   host_scan_scheduler_->OnSyncFinished(
       cryptauth::CryptAuthDeviceManager::SyncResult::SUCCESS,
       cryptauth::CryptAuthDeviceManager::DeviceChangeResult::UNCHANGED);
-  EXPECT_EQ(1, mock_host_scanner_->num_scans_started());
+  EXPECT_EQ(1, fake_host_scanner_->num_scans_started());
 }
 
 }  // namespace tether