Convert path usage in NetworkListViewBase subclasses to use guids.

ash/common/system/chromeos/network/network_list.cc

 // Copyright 2014 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 "ash/common/system/chromeos/network/network_list.h"
 
 #include <stddef.h>
 
 #include "ash/common/system/chromeos/network/network_icon.h"
 #include "ash/common/system/chromeos/network/network_icon_animation.h"
@@ skipping 67 matching lines @@
   CHECK(container());
   NetworkStateHandler::NetworkStateList network_list;
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   handler->GetVisibleNetworkList(&network_list);
   UpdateNetworks(network_list);
   UpdateNetworkIcons();
   UpdateNetworkListInternal();
 }
 
 bool NetworkListView::IsNetworkEntry(views::View* view,
-                                     std::string* service_path) const {
+                                     std::string* guid) const {
   std::map<views::View*, std::string>::const_iterator found =
       network_map_.find(view);
   if (found == network_map_.end())
     return false;
-  *service_path = found->second;
+  *guid = found->second;
   return true;
 }
 
 void NetworkListView::UpdateNetworks(
     const NetworkStateHandler::NetworkStateList& networks) {
   SCOPED_NET_LOG_IF_SLOW();
   network_list_.clear();
   const NetworkTypePattern pattern = delegate_->GetNetworkTypePattern();
   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
            networks.begin();
        iter != networks.end(); ++iter) {
     const chromeos::NetworkState* network = *iter;
     if (!pattern.MatchesType(network->type()))
       continue;
-    network_list_.push_back(base::MakeUnique<NetworkInfo>(network->path()));
+    network_list_.push_back(base::MakeUnique<NetworkInfo>(network->guid()));
   }
 }
 
 void NetworkListView::UpdateNetworkIcons() {
   SCOPED_NET_LOG_IF_SLOW();
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   // First, update state for all networks
   bool animating = false;
 
   for (auto& info : network_list_) {
     const chromeos::NetworkState* network =
-        handler->GetNetworkState(info->service_path);
+        handler->GetNetworkStateFromGuid(info->guid);
     if (!network)
       continue;
     bool prohibited_by_policy = IsProhibitedByPolicy(network);
     info->image =
         network_icon::GetImageForNetwork(network, network_icon::ICON_TYPE_LIST);
     info->label =
         network_icon::GetLabelForNetwork(network, network_icon::ICON_TYPE_LIST);
     info->highlight =
         network->IsConnectedState() || network->IsConnectingState();
     info->disable =
@@ skipping 13 matching lines @@
   if (animating)
     network_icon::NetworkIconAnimation::GetInstance()->AddObserver(this);
   else
     network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
 }
 
 void NetworkListView::UpdateNetworkListInternal() {
   SCOPED_NET_LOG_IF_SLOW();
   // Get the updated list entries
   network_map_.clear();
-  std::set<std::string> new_service_paths;
-  bool needs_relayout = UpdateNetworkListEntries(&new_service_paths);
+  std::set<std::string> new_guids;
+  bool needs_relayout = UpdateNetworkListEntries(&new_guids);
 
   // Remove old children
-  std::set<std::string> remove_service_paths;
-  for (ServicePathMap::const_iterator it = service_path_map_.begin();
-       it != service_path_map_.end(); ++it) {
-    if (new_service_paths.find(it->first) == new_service_paths.end()) {
-      remove_service_paths.insert(it->first);
+  std::set<std::string> remove_guids;
+  for (NetworkGuidMap::const_iterator it = network_guid_map_.begin();
+       it != network_guid_map_.end(); ++it) {
+    if (new_guids.find(it->first) == new_guids.end()) {
+      remove_guids.insert(it->first);
       network_map_.erase(it->second);
       delete it->second;
       needs_relayout = true;
     }
   }
 
-  for (std::set<std::string>::const_iterator remove_it =
-           remove_service_paths.begin();
-       remove_it != remove_service_paths.end(); ++remove_it) {
-    service_path_map_.erase(*remove_it);
+  for (std::set<std::string>::const_iterator remove_it = remove_guids.begin();
+       remove_it != remove_guids.end(); ++remove_it) {
+    network_guid_map_.erase(*remove_it);
   }
 
   if (needs_relayout)
     HandleRelayout();
 }
 
 void NetworkListView::HandleRelayout() {
   views::View* selected_view = nullptr;
-  for (auto& iter : service_path_map_) {
+  for (auto& iter : network_guid_map_) {
     if (delegate_->IsViewHovered(iter.second)) {
       selected_view = iter.second;
       break;
     }
   }
   container()->SizeToPreferredSize();
   delegate_->RelayoutScrollList();
   if (selected_view)
     container()->ScrollRectToVisible(selected_view->bounds());
 }
 
 bool NetworkListView::UpdateNetworkListEntries(
-    std::set<std::string>* new_service_paths) {
+    std::set<std::string>* new_guids) {
   bool needs_relayout = false;
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   // Insert child views
   int index = 0;
 
   // Highlighted networks
   needs_relayout |=
-      UpdateNetworkChildren(new_service_paths, &index, true /* highlighted */);
+      UpdateNetworkChildren(new_guids, &index, true /* highlighted */);
 
   const NetworkTypePattern pattern = delegate_->GetNetworkTypePattern();
   if (pattern.MatchesPattern(NetworkTypePattern::Cellular())) {
     // Cellular initializing
     int message_id = network_icon::GetCellularUninitializedMsg();
     if (!message_id &&
         handler->IsTechnologyEnabled(NetworkTypePattern::Mobile()) &&
         !handler->FirstNetworkByType(NetworkTypePattern::Mobile())) {
       message_id = IDS_ASH_STATUS_TRAY_NO_CELLULAR_NETWORKS;
     }
@@ skipping 12 matching lines @@
                        ? IDS_ASH_STATUS_TRAY_NETWORK_WIFI_ENABLED
                        : IDS_ASH_STATUS_TRAY_NETWORK_WIFI_DISABLED;
     }
     needs_relayout |=
         UpdateInfoLabel(message_id, index, &no_wifi_networks_view_);
     if (message_id)
       ++index;
   }
 
   // Un-highlighted networks
-  needs_relayout |= UpdateNetworkChildren(new_service_paths, &index,
-                                          false /* not highlighted */);
+  needs_relayout |=
+      UpdateNetworkChildren(new_guids, &index, false /* not highlighted */);
 
   // No networks or other messages (fallback)
   if (index == 0) {
     needs_relayout |= UpdateInfoLabel(IDS_ASH_STATUS_TRAY_NO_NETWORKS, index,
                                       &no_wifi_networks_view_);
   }
 
   return needs_relayout;
 }
 
-bool NetworkListView::UpdateNetworkChildren(
-    std::set<std::string>* new_service_paths,
-    int* child_index,
-    bool highlighted) {
+bool NetworkListView::UpdateNetworkChildren(std::set<std::string>* new_guids,
+                                            int* child_index,
+                                            bool highlighted) {
   bool needs_relayout = false;
   int index = *child_index;
   for (auto& info : network_list_) {
     if (info->highlight != highlighted)
       continue;
     needs_relayout |= UpdateNetworkChild(index++, info.get());
-    new_service_paths->insert(info->service_path);
+    new_guids->insert(info->guid);
   }
   *child_index = index;
   return needs_relayout;
 }
 
 bool NetworkListView::UpdateNetworkChild(int index, const NetworkInfo* info) {
   bool needs_relayout = false;
   views::View* network_view = nullptr;
-  ServicePathMap::const_iterator found =
-      service_path_map_.find(info->service_path);
-  if (found == service_path_map_.end()) {
+  NetworkGuidMap::const_iterator found = network_guid_map_.find(info->guid);
+  if (found == network_guid_map_.end()) {
     network_view = delegate_->CreateViewForNetwork(*info);
     container()->AddChildViewAt(network_view, index);
     needs_relayout = true;
   } else {
     network_view = found->second;
     network_view->RemoveAllChildViews(true);
     delegate_->UpdateViewForNetwork(network_view, *info);
     network_view->Layout();
     network_view->SchedulePaint();
     needs_relayout = PlaceViewAtIndex(network_view, index);
   }
   if (info->disable)
     network_view->SetEnabled(false);
-  network_map_[network_view] = info->service_path;
-  service_path_map_[info->service_path] = network_view;
+  network_map_[network_view] = info->guid;
+  network_guid_map_[info->guid] = network_view;
   return needs_relayout;
 }
 
 bool NetworkListView::PlaceViewAtIndex(views::View* view, int index) {
   if (container()->child_at(index) == view)
     return false;
   container()->ReorderChildView(view, index);
   return true;
 }
 
@@ skipping 20 matching lines @@
     needs_relayout = true;
   }
   return needs_relayout;
 }
 
 void NetworkListView::NetworkIconChanged() {
   Update();
 }
 
 }  // namespace ash