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 23 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)
+    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