Tether: Persist if first-time setup is required to HostScanCache.

chromeos/components/tether/host_scan_cache_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/host_scan_cache.h"
 
 #include <memory>
 #include <unordered_map>
 #include <vector>
 
@@ skipping 39 matching lines @@
 const int kTetherBatteryPercentage0 = 20;
 const int kTetherBatteryPercentage1 = 40;
 const int kTetherBatteryPercentage2 = 60;
 const int kTetherBatteryPercentage3 = 80;
 
 const int kTetherSignalStrength0 = 25;
 const int kTetherSignalStrength1 = 50;
 const int kTetherSignalStrength2 = 75;
 const int kTetherSignalStrength3 = 100;
 
+const bool kTetherSetupRequired0 = true;
+const bool kTetherSetupRequired1 = false;
+const bool kTetherSetupRequired2 = true;
+const bool kTetherSetupRequired3 = false;
+
 // MockTimer which invokes a callback in its destructor.
 class ExtendedMockTimer : public base::MockTimer {
  public:
   explicit ExtendedMockTimer(const base::Closure& destructor_callback)
       : base::MockTimer(true /* retain_user_task */, false /* is_repeating */),
         destructor_callback_(destructor_callback) {}
 
   ~ExtendedMockTimer() override { destructor_callback_.Run(); }
 
  private:
@@ skipping 127 matching lines @@
   // at the top of this test file.
   void SetCacheScanResultForDeviceIndex(int32_t index) {
     // There are 4 sets of test constants.
     ASSERT_TRUE(index >= 0 && index <= 3);
 
     std::string tether_network_guid;
     std::string device_name;
     std::string carrier;
     int battery_percentage;
     int signal_strength;
+    bool setup_required;
 
     switch (index) {
       case 0:
         tether_network_guid = kTetherGuid0;
         device_name = kTetherDeviceName0;
         carrier = kTetherCarrier0;
         battery_percentage = kTetherBatteryPercentage0;
         signal_strength = kTetherSignalStrength0;
+        setup_required = kTetherSetupRequired0;
         break;
       case 1:
         tether_network_guid = kTetherGuid1;
         device_name = kTetherDeviceName1;
         carrier = kTetherCarrier1;
         battery_percentage = kTetherBatteryPercentage1;
         signal_strength = kTetherSignalStrength1;
+        setup_required = kTetherSetupRequired1;
         break;
       case 2:
         tether_network_guid = kTetherGuid2;
         device_name = kTetherDeviceName2;
         carrier = kTetherCarrier2;
         battery_percentage = kTetherBatteryPercentage2;
         signal_strength = kTetherSignalStrength2;
+        setup_required = kTetherSetupRequired2;
         break;
       case 3:
         tether_network_guid = kTetherGuid3;
         device_name = kTetherDeviceName3;
         carrier = kTetherCarrier3;
         battery_percentage = kTetherBatteryPercentage3;
         signal_strength = kTetherSignalStrength3;
+        setup_required = kTetherSetupRequired3;
         break;
       default:
         NOTREACHED();
-        // Set values for |battery_percentage| and |signal_strength| here to
-        // prevent a compiler warning which says that they may be unset at this
-        // point.
+        // Set values for |battery_percentage|, |signal_strength| and
+        // setup_required here to prevent a compiler warning which says that

[Kyle Horimoto, 2017/05/31 23:01:19]

|setup_required|

[Ryan Hansberry, 2017/06/01 01:07:51]

Done.

+        // they may be unset at this point.
         battery_percentage = 0;
         signal_strength = 0;
+        setup_required = false;
         break;
     }
 
     SetHostScanResult(tether_network_guid, device_name, carrier,
-                      battery_percentage, signal_strength);
+                      battery_percentage, signal_strength, setup_required);
   }
 
   void SetHostScanResult(const std::string& tether_network_guid,
                          const std::string& device_name,
                          const std::string& carrier,
                          int battery_percentage,
-                         int signal_strength) {
+                         int signal_strength,
+                         bool setup_required) {
     test_timer_factory_->set_tether_network_guid_for_next_timer(
         tether_network_guid);
     host_scan_cache_->SetHostScanResult(tether_network_guid, device_name,
                                         carrier, battery_percentage,
-                                        signal_strength);
+                                        signal_strength, setup_required);
     expected_cache_->SetHostScanResult(tether_network_guid, device_name,
                                        carrier, battery_percentage,
-                                       signal_strength);
+                                       signal_strength, setup_required);
   }
 
   void RemoveHostScanResult(const std::string& tether_network_guid) {
     host_scan_cache_->RemoveHostScanResult(tether_network_guid);
     expected_cache_->RemoveHostScanResult(tether_network_guid);
   }
 
   void ClearCacheExceptForActiveHost() {
     host_scan_cache_->ClearCacheExceptForActiveHost();
     expected_cache_->ClearCacheExceptForActiveHost();
@@ skipping 18 matching lines @@
       // corresponding entry in NetworkStateHandler.
       const NetworkState* tether_network_state =
           network_state_handler()->GetNetworkStateFromGuid(tether_network_guid);
       ASSERT_TRUE(tether_network_state);
       EXPECT_EQ(cache_entry.device_name, tether_network_state->name());
       EXPECT_EQ(cache_entry.carrier, tether_network_state->carrier());
       EXPECT_EQ(cache_entry.battery_percentage,
                 tether_network_state->battery_percentage());
       EXPECT_EQ(cache_entry.signal_strength,
                 tether_network_state->signal_strength());
+      EXPECT_EQ(cache_entry.setup_required,
+                host_scan_cache_->DoesHostRequireSetup(tether_network_guid));
       EXPECT_EQ(HasConnectedToHost(tether_network_guid),
                 tether_network_state->tether_has_connected_to_host());
 
       // Ensure that each entry has an actively-running Timer.
       auto timer_map_it =
           test_timer_factory_->tether_network_guid_to_timer_map().begin();
       EXPECT_NE(timer_map_it,
                 test_timer_factory_->tether_network_guid_to_timer_map().end());
       EXPECT_TRUE(timer_map_it->second->IsRunning());
     }
@@ skipping 53 matching lines @@
 }
 
 TEST_F(HostScanCacheTest, TestSetScanResultThenUpdateAndRemove) {
   SetCacheScanResultForDeviceIndex(0);
   EXPECT_EQ(1u, expected_cache_->size());
   VerifyCacheMatchesNetworkStack();
 
   // Change the fields for tether network with GUID |kTetherGuid0| to the
   // fields corresponding to |kTetherGuid1|.
   SetHostScanResult(kTetherGuid0, kTetherDeviceName0, kTetherCarrier1,
-                    kTetherBatteryPercentage1, kTetherSignalStrength1);
+                    kTetherBatteryPercentage1, kTetherSignalStrength1,
+                    kTetherSetupRequired1);
   EXPECT_EQ(1u, expected_cache_->size());
   VerifyCacheMatchesNetworkStack();
 
   // Now, remove that result.
   RemoveHostScanResult(kTetherGuid0);
   EXPECT_TRUE(expected_cache_->empty());
   VerifyCacheMatchesNetworkStack();
 }
 
 TEST_F(HostScanCacheTest, TestSetScanResult_SetActiveHost_ThenClear) {
@@ skipping 52 matching lines @@
 
   // Simulate a connection to device 1.
   SetActiveHost(kTetherGuid1);
   SetHasConnectedToHost(kTetherGuid1);
   VerifyCacheMatchesNetworkStack();
 }
 
 }  // namespace tether
 
 }  // namespace chromeos