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

chromeos/components/tether/host_scan_cache.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 37 matching lines @@
 }
 
 HostScanCache::~HostScanCache() {
   tether_host_response_recorder_->RemoveObserver(this);
 }
 
 void HostScanCache::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) {
   DCHECK(!tether_network_guid.empty());
 
   auto found_iter = tether_guid_to_timer_map_.find(tether_network_guid);
 
   if (found_iter == tether_guid_to_timer_map_.end()) {
     // Add the Tether network to NetworkStateHandler and create an associated
     // Timer.
     network_state_handler_->AddTetherNetworkState(
         tether_network_guid, device_name, carrier, battery_percentage,
         signal_strength, HasConnectedToHost(tether_network_guid));
@@ skipping 10 matching lines @@
     network_state_handler_->UpdateTetherNetworkProperties(
         tether_network_guid, carrier, battery_percentage, signal_strength);
     found_iter->second->Stop();
 
     PA_LOG(INFO) << "Updated scan result for Tether network with GUID "
                  << tether_network_guid << ". New carrier: " << carrier << ", "
                  << "new battery percentage: " << battery_percentage << ", "
                  << "new signal strength: " << signal_strength;
   }
 
+  if (setup_required)

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

Previously, you forgot to add this if(), but the tests still passed despite this
error. Were you able to determine why the tests still passed and ensure that the
tests are now correctly making this assertion?

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

Mentioned this on the past commit: This was actually causing the tests to fail.
After fixing this, the tests pass.

+    setup_required_tether_guids_.insert(tether_network_guid);
+  else
+    setup_required_tether_guids_.erase(tether_network_guid);
+
   StartTimer(tether_network_guid);
 }
 
 bool HostScanCache::RemoveHostScanResult(
     const std::string& tether_network_guid) {
   DCHECK(!tether_network_guid.empty());
 
   auto it = tether_guid_to_timer_map_.find(tether_network_guid);
   if (it == tether_guid_to_timer_map_.end()) {
     PA_LOG(ERROR) << "Attempted to remove a host scan result which does not "
                   << "exist in the cache. GUID: " << tether_network_guid;
     return false;
   }
 
   if (active_host_->GetTetherNetworkGuid() == tether_network_guid) {
     PA_LOG(ERROR) << "RemoveHostScanResult() called for Tether network with "
                   << "GUID " << tether_network_guid << ", but the "
                   << "corresponding device is the active host. Not removing "
                   << "this scan result from the cache.";
     return false;
   }
 
   tether_guid_to_timer_map_.erase(it);
+  setup_required_tether_guids_.erase(tether_network_guid);
   return network_state_handler_->RemoveTetherNetworkState(tether_network_guid);
 }
 
 void HostScanCache::ClearCacheExceptForActiveHost() {
   // Create a list of all Tether network GUIDs serving as keys to
   // |tether_guid_to_timer_map_|.
   std::vector<std::string> tether_network_guids;
   tether_network_guids.reserve(tether_guid_to_timer_map_.size());
   for (auto& it : tether_guid_to_timer_map_)
     tether_network_guids.push_back(it.first);
@@ skipping 18 matching lines @@
   for (auto& tether_network_guid : tether_network_guids) {
     if (active_host_->GetTetherNetworkGuid() == tether_network_guid) {
       // Do not remove the active host from the cache.
       continue;
     }
 
     RemoveHostScanResult(tether_network_guid);
   }
 }
 
+bool HostScanCache::DoesHostRequireSetup(
+    const std::string& tether_network_guid) {
+  return setup_required_tether_guids_.find(tether_network_guid) !=
+         setup_required_tether_guids_.end();
+}
+
 void HostScanCache::OnPreviouslyConnectedHostIdsChanged() {
   for (auto& map_entry : tether_guid_to_timer_map_) {
     const std::string& tether_network_guid = map_entry.first;
     if (!HasConnectedToHost(tether_network_guid))
       continue;
 
     // If a the current device has connected to the Tether network with GUID
     // |tether_network_guid|, alert |network_state_handler_|. Note that this
     // function is a no-op if it is called on a network which already has its
     // HasConnectedToHost property set to true.
@@ skipping 58 matching lines @@
   }
 
   PA_LOG(INFO) << "Timer fired for Tether network GUID " << tether_network_guid
                << ". Removing stale scan result.";
   RemoveHostScanResult(tether_network_guid);
 }
 
 }  // namespace tether
 
 }  // namespace chromeos