Tether: only scan when asked to by NetworkStateHandler.

chromeos/components/tether/host_scanner_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.h"
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
+#include "base/test/simple_test_clock.h"
+#include "base/time/time.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
 #include "chromeos/components/tether/fake_host_scan_cache.h"
 #include "chromeos/components/tether/fake_notification_presenter.h"
 #include "chromeos/components/tether/fake_tether_host_fetcher.h"
 #include "chromeos/components/tether/host_scan_device_prioritizer.h"
 #include "chromeos/components/tether/host_scanner.h"
 #include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
+class TestObserver : public HostScanner::Observer {
+ public:
+  void ScanFinished() override { scan_finished_count_++; }
+
+  int scan_finished_count() { return scan_finished_count_; }
+
+ private:
+  int scan_finished_count_ = 0;
+};
+
 class FakeHostScanDevicePrioritizer : public HostScanDevicePrioritizer {
  public:
   FakeHostScanDevicePrioritizer() : HostScanDevicePrioritizer(nullptr) {}
   ~FakeHostScanDevicePrioritizer() override {}
 
   // Simply leave |remote_devices| as-is.
   void SortByHostScanOrder(
       std::vector<cryptauth::RemoteDevice>* remote_devices) const override {}
 };
 
@@ skipping 174 matching lines @@
         base::MakeUnique<FakeNotificationPresenter>();
     device_id_tether_network_guid_map_ =
         base::MakeUnique<DeviceIdTetherNetworkGuidMap>();
     fake_host_scan_cache_ = base::MakeUnique<FakeHostScanCache>();
 
     fake_host_scanner_operation_factory_ =
         base::WrapUnique(new FakeHostScannerOperationFactory(test_devices_));
     HostScannerOperation::Factory::SetInstanceForTesting(
         fake_host_scanner_operation_factory_.get());
 
+    test_clock_ = base::MakeUnique<base::SimpleTestClock>();
+
     host_scanner_ = base::WrapUnique(new HostScanner(
         fake_tether_host_fetcher_.get(), fake_ble_connection_manager_.get(),
         fake_host_scan_device_prioritizer_.get(),
         mock_tether_host_response_recorder_.get(),
         fake_notification_presenter_.get(),
-        device_id_tether_network_guid_map_.get(), fake_host_scan_cache_.get()));
+        device_id_tether_network_guid_map_.get(), fake_host_scan_cache_.get(),
+        test_clock_.get()));
+
+    test_observer_ = base::MakeUnique<TestObserver>();
+    host_scanner_->AddObserver(test_observer_.get());
   }
 
   void TearDown() override {
+    host_scanner_->RemoveObserver(test_observer_.get());
     HostScannerOperation::Factory::SetInstanceForTesting(nullptr);
   }
 
   // Causes |fake_operation| to receive the scan result in
   // |test_scanned_device_infos| vector at the index |test_device_index| with
   // the "final result" value of |is_final_scan_result|.
   void ReceiveScanResultAndVerifySuccess(
       FakeHostScannerOperation& fake_operation,
       size_t test_device_index,
       bool is_final_scan_result) {
     bool already_in_list = false;
     for (auto& scanned_device_info : scanned_device_infos_so_far_) {
       if (scanned_device_info.remote_device.GetDeviceId() ==
           test_devices_[test_device_index].GetDeviceId()) {
         already_in_list = true;
         break;
       }
     }
 
     if (!already_in_list) {
       scanned_device_infos_so_far_.push_back(
           test_scanned_device_infos[test_device_index]);
     }
 
+    int previous_scan_finished_count = test_observer_->scan_finished_count();
     fake_operation.SendScannedDeviceListUpdate(scanned_device_infos_so_far_,
                                                is_final_scan_result);
     VerifyScanResultsMatchCache();
+    EXPECT_EQ(previous_scan_finished_count + (is_final_scan_result ? 1 : 0),
+              test_observer_->scan_finished_count());
 
     if (scanned_device_infos_so_far_.size() == 1) {
       EXPECT_EQ(FakeNotificationPresenter::PotentialHotspotNotificationState::
                     SINGLE_HOTSPOT_NEARBY_SHOWN,
                 fake_notification_presenter_->potential_hotspot_state());
     } else {
       EXPECT_EQ(FakeNotificationPresenter::PotentialHotspotNotificationState::
                     MULTIPLE_HOTSPOTS_NEARBY_SHOWN,
                 fake_notification_presenter_->potential_hotspot_state());
     }
@@ skipping 48 matching lines @@
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
   std::unique_ptr<HostScanDevicePrioritizer> fake_host_scan_device_prioritizer_;
   std::unique_ptr<MockTetherHostResponseRecorder>
       mock_tether_host_response_recorder_;
   std::unique_ptr<FakeNotificationPresenter> fake_notification_presenter_;
   // 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::unique_ptr<FakeHostScanCache> fake_host_scan_cache_;
 
+  std::unique_ptr<base::SimpleTestClock> test_clock_;
+  std::unique_ptr<TestObserver> test_observer_;
+
   std::unique_ptr<FakeHostScannerOperationFactory>
       fake_host_scanner_operation_factory_;
 
   std::vector<HostScannerOperation::ScannedDeviceInfo>
       scanned_device_infos_so_far_;
 
   std::unique_ptr<HostScanner> host_scanner_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HostScannerTest);
@@ skipping 191 matching lines @@
   EXPECT_TRUE(host_scanner_->IsScanActive());
 
   // Finish the second scan.
   fake_host_scanner_operation_factory_->created_operations()[1]
       ->SendScannedDeviceListUpdate(scanned_device_infos_so_far_,
                                     true /* is_final_scan_result */);
   EXPECT_EQ(scanned_device_infos_so_far_.size(), fake_host_scan_cache_->size());
   EXPECT_FALSE(host_scanner_->IsScanActive());
 }
 
+TEST_F(HostScannerTest, HasRecentlyScanned) {
+  test_clock_->SetNow(base::Time::Now());
+
+  host_scanner_->StartScan();
+  fake_tether_host_fetcher_->InvokePendingCallbacks();
+
+  ReceiveScanResultAndVerifySuccess(
+      *fake_host_scanner_operation_factory_->created_operations()[0],
+      0u /* test_device_index */, false /* is_final_scan_result */);
+  ReceiveScanResultAndVerifySuccess(
+      *fake_host_scanner_operation_factory_->created_operations()[0],
+      1u /* test_device_index */, true /* is_final_scan_result */);
+
+  // We have just scanned.
+  EXPECT_TRUE(host_scanner_->HasRecentlyScanned());
+
+  int time_limit_minutes = HostScanCache::kNumMinutesBeforeCacheEntryExpires;
+  int time_limit_seconds = time_limit_minutes * 60;
+  int time_limit_half_seconds = time_limit_seconds / 2;
+  int time_limit_threshold_seconds =
+      time_limit_seconds - time_limit_half_seconds - 1;
+
+  // Move up some amount of time, but not the full limit.
+  test_clock_->Advance(base::TimeDelta::FromSeconds(time_limit_half_seconds));
+  EXPECT_TRUE(host_scanner_->HasRecentlyScanned());
+
+  // Move right up to the limit.
+  test_clock_->Advance(
+      base::TimeDelta::FromSeconds(time_limit_threshold_seconds));
+  EXPECT_TRUE(host_scanner_->HasRecentlyScanned());
+
+  // Move past the limit.
+  test_clock_->Advance(base::TimeDelta::FromSeconds(1));
+  EXPECT_FALSE(host_scanner_->HasRecentlyScanned());
+}
+
 }  // namespace tether
 
 }  // namespace chromeos