Convert path usage in NetworkListViewBase subclasses to use guids.

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

 // Copyright 2015 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/vpn_list_view.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 145 matching lines @@
   // network_icon::AnimationObserver:
   void NetworkIconChanged() override;
 
  private:
   void UpdateFromNetworkState(const chromeos::NetworkState* network);
   void SetupConnectedItemMd(const base::string16& text,
                             const gfx::ImageSkia& image);
   void SetupConnectingItemMd(const base::string16& text,
                              const gfx::ImageSkia& image);
 
-  const std::string service_path_;
+  const std::string guid_;
 
   views::LabelButton* disconnect_button_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(VPNListNetworkEntry);
 };
 
 VPNListEntryBase::VPNListEntryBase(VPNListView* parent)
     : HoverHighlightView(parent) {
   if (!UseMd())
     SetBorder(views::CreateEmptyBorder(0, kTrayPopupPaddingHorizontal, 0, 0));
 }
 
 VPNListNetworkEntry::VPNListNetworkEntry(VPNListView* parent,
                                          const chromeos::NetworkState* network)
-    : VPNListEntryBase(parent), service_path_(network->path()) {
+    : VPNListEntryBase(parent), guid_(network->guid()) {
   UpdateFromNetworkState(network);
 }
 
 VPNListNetworkEntry::~VPNListNetworkEntry() {
   network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
 }
 
 void VPNListNetworkEntry::NetworkIconChanged() {
-  UpdateFromNetworkState(
-      chromeos::NetworkHandler::Get()->network_state_handler()->GetNetworkState(
-          service_path_));
+  UpdateFromNetworkState(chromeos::NetworkHandler::Get()
+                             ->network_state_handler()
+                             ->GetNetworkStateFromGuid(guid_));
 }
 
 void VPNListNetworkEntry::UpdateFromNetworkState(
     const chromeos::NetworkState* network) {
   if (network && network->IsConnectingState())
     network_icon::NetworkIconAnimation::GetInstance()->AddObserver(this);
   else
     network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
 
   if (!network) {
@@ skipping 57 matching lines @@
 }
 
 VPNListView::~VPNListView() {
   WmShell::Get()->vpn_list()->RemoveObserver(this);
 }
 
 void VPNListView::Update() {
   // Before updating the list, determine whether the user was hovering over one
   // of the VPN provider or network entries.
   std::unique_ptr<VPNProvider> hovered_provider;
-  std::string hovered_network_service_path;
+  std::string hovered_network_guid;
   for (const std::pair<const views::View* const, VPNProvider>& provider :
        provider_view_map_) {
     if (static_cast<const HoverHighlightView*>(provider.first)->hover()) {
       hovered_provider.reset(new VPNProvider(provider.second));
       break;
     }
   }
   if (!hovered_provider) {
     for (const std::pair<const views::View*, std::string>& entry :
-         network_view_service_path_map_) {
+         network_view_guid_map_) {
       if (static_cast<const HoverHighlightView*>(entry.first)->hover()) {
-        hovered_network_service_path = entry.second;
+        hovered_network_guid = entry.second;
         break;
       }
     }
   }
 
   // Clear the list.
   container()->RemoveAllChildViews(true);
   provider_view_map_.clear();
-  network_view_service_path_map_.clear();
+  network_view_guid_map_.clear();
   list_empty_ = true;
   if (!UseMd()) {
     container()->SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   }
 
   // Get the list of available VPN networks, in shill's priority order.
   chromeos::NetworkStateHandler::NetworkStateList networks;
   chromeos::NetworkHandler::Get()
       ->network_state_handler()
       ->GetVisibleNetworkListByType(chromeos::NetworkTypePattern::VPN(),
                                     &networks);
 
   // Show all VPN providers and all networks that are currently disconnected.
   AddProvidersAndNetworks(networks);
 
   // Determine whether one of the new list entries corresponds to the entry that
   // the user was previously hovering over. If such an entry is found, the list
   // will be scrolled to ensure the entry is visible.
   const views::View* scroll_to_show_view = nullptr;
   if (hovered_provider) {
     for (const std::pair<const views::View* const, VPNProvider>& provider :
          provider_view_map_) {
       if (provider.second == *hovered_provider) {
         scroll_to_show_view = provider.first;
         break;
       }
     }
-  } else if (!hovered_network_service_path.empty()) {
+  } else if (!hovered_network_guid.empty()) {
     for (const std::pair<const views::View*, std::string>& entry :
-         network_view_service_path_map_) {
-      if (entry.second == hovered_network_service_path) {
+         network_view_guid_map_) {
+      if (entry.second == hovered_network_guid) {
         scroll_to_show_view = entry.first;
         break;
       }
     }
   }
 
   // Layout the updated list.
   container()->SizeToPreferredSize();
   delegate_->RelayoutScrollList();
 
   if (scroll_to_show_view) {
     // Scroll the list so that |scroll_to_show_view| is in view.
     container()->ScrollRectToVisible(scroll_to_show_view->bounds());
   }
 }
 
-bool VPNListView::IsNetworkEntry(views::View* view,
-                                 std::string* service_path) const {
-  const auto& entry = network_view_service_path_map_.find(view);
-  if (entry == network_view_service_path_map_.end())
+bool VPNListView::IsNetworkEntry(views::View* view, std::string* guid) const {
+  const auto& entry = network_view_guid_map_.find(view);
+  if (entry == network_view_guid_map_.end())
     return false;
-  *service_path = entry->second;
+  *guid = entry->second;
   return true;
 }
 
 void VPNListView::OnVPNProvidersChanged() {
   Update();
 }
 
 void VPNListView::OnViewClicked(views::View* sender) {
   const auto& provider_iter = provider_view_map_.find(sender);
   if (provider_iter != provider_view_map_.end()) {
@@ skipping 15 matching lines @@
 
   // If the user clicked on a network entry, let the |delegate_| trigger a
   // connection attempt (if the network is currently disconnected) or show a
   // configuration dialog (if the network is currently connected or connecting).
   delegate_->OnNetworkEntryClicked(sender);
 }
 
 void VPNListView::AddNetwork(const chromeos::NetworkState* network) {
   views::View* entry(new VPNListNetworkEntry(this, network));
   container()->AddChildView(entry);
-  network_view_service_path_map_[entry] = network->path();
+  network_view_guid_map_[entry] = network->guid();
   list_empty_ = false;
 }
 
 void VPNListView::AddProviderAndNetworks(
     const VPNProvider& vpn_provider,
     const chromeos::NetworkStateHandler::NetworkStateList& networks) {
   // Add a visual separator, unless this is the topmost entry in the list.
   if (!list_empty_)
     container()->AddChildView(TrayPopupUtils::CreateListSubHeaderSeparator());
   std::string vpn_name =
@@ skipping 40 matching lines @@
     }
   }
 
   // Add providers without any configured networks, in the order that the
   // providers were returned by the extensions system.
   for (const VPNProvider& provider : providers)
     AddProviderAndNetworks(provider, networks);
 }
 
 }  // namespace ash