chromeos: Move ownership of ash VPN provider list from chrome into ash

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 16 matching lines @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "grit/ash_strings.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/separator.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/view.h"
 
 namespace ash {
 
 namespace {
 
 bool UseMd() {
   return MaterialDesignController::IsSystemTrayMenuMaterial();
 }
 
 bool IsConnectedOrConnecting(const chromeos::NetworkState* network) {
   return network->IsConnectedState() || network->IsConnectingState();
 }
 
 void IgnoreDisconnectError(const std::string& error_name,
                            std::unique_ptr<base::DictionaryValue> error_data) {}
 
+// Indicates whether |network| belongs to this VPN provider.
+bool VpnProviderMatchesNetwork(const VPNProvider& provider,
+                               const chromeos::NetworkState& network) {
+  if (network.type() != shill::kTypeVPN)
+    return false;
+  const bool network_uses_third_party_provider =
+      network.vpn_provider_type() == shill::kProviderThirdPartyVpn;
+  if (!provider.third_party)
+    return !network_uses_third_party_provider;
+  return network_uses_third_party_provider &&
+         network.third_party_vpn_provider_extension_id() ==
+             provider.extension_id;
+}

[stevenjb, 2016/11/22 00:08:35]

Thanks for moving this, I meant to suggest that before.

+
 // The base class of all list entries, a |HoverHighlightView| with no border.
 class VPNListEntryBase : public HoverHighlightView {
  public:
   // When the user clicks the entry, the |parent|'s OnViewClicked() will be
   // invoked.
   explicit VPNListEntryBase(VPNListView* parent);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VPNListEntryBase);
 };
@@ skipping 239 matching lines @@
   if (system_tray_delegate) {
     VPNDelegate* const vpn_delegate = system_tray_delegate->GetVPNDelegate();
     if (vpn_delegate)
       vpn_delegate->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::Key> hovered_provider_key;
+  std::unique_ptr<VPNProvider> hovered_provider;
   std::string hovered_network_service_path;
-  for (const std::pair<const views::View* const, VPNProvider::Key>& provider :
-       provider_view_key_map_) {
+  for (const std::pair<const views::View* const, VPNProvider>& provider :
+       provider_view_map_) {
     if (static_cast<const HoverHighlightView*>(provider.first)->hover()) {
-      hovered_provider_key.reset(new VPNProvider::Key(provider.second));
+      hovered_provider.reset(new VPNProvider(provider.second));
       break;
     }
   }
-  if (!hovered_provider_key) {
+  if (!hovered_provider) {
     for (const std::pair<const views::View*, std::string>& entry :
          network_view_service_path_map_) {
       if (static_cast<const HoverHighlightView*>(entry.first)->hover()) {
         hovered_network_service_path = entry.second;
         break;
       }
     }
   }
 
   // Clear the list.
   container()->RemoveAllChildViews(true);
-  provider_view_key_map_.clear();
+  provider_view_map_.clear();
   network_view_service_path_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);
 
   if (!networks.empty() && IsConnectedOrConnecting(networks.front())) {
     // If there is a connected or connecting network, show that network first.
     AddNetwork(networks.front());
     networks.erase(networks.begin());
   }
 
   // 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_key) {
-    for (const std::pair<const views::View* const, VPNProvider::Key>& provider :
-         provider_view_key_map_) {
-      if (provider.second == *hovered_provider_key) {
+  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()) {
     for (const std::pair<const views::View*, std::string>& entry :
          network_view_service_path_map_) {
       if (entry.second == hovered_network_service_path) {
         scroll_to_show_view = entry.first;
         break;
@@ skipping 18 matching lines @@
     return false;
   *service_path = entry->second;
   return true;
 }
 
 void VPNListView::OnVPNProvidersChanged() {
   Update();
 }
 
 void VPNListView::OnViewClicked(views::View* sender) {
-  const auto& provider = provider_view_key_map_.find(sender);
-  if (provider != provider_view_key_map_.end()) {
+  const auto& provider_iter = provider_view_map_.find(sender);
+  if (provider_iter != provider_view_map_.end()) {
     // If the user clicks on a provider entry, request that the "add network"
     // dialog for this provider be shown.
-    const VPNProvider::Key& key = provider->second;
+    const VPNProvider& provider = provider_iter->second;
     WmShell::Get()->RecordUserMetricsAction(
-        key.third_party ? UMA_STATUS_AREA_VPN_ADD_THIRD_PARTY_CLICKED
-                        : UMA_STATUS_AREA_VPN_ADD_BUILT_IN_CLICKED);
-    WmShell::Get()->system_tray_delegate()->GetVPNDelegate()->ShowAddPage(key);
+        provider.third_party ? UMA_STATUS_AREA_VPN_ADD_THIRD_PARTY_CLICKED
+                             : UMA_STATUS_AREA_VPN_ADD_BUILT_IN_CLICKED);
+    WmShell::Get()->system_tray_delegate()->GetVPNDelegate()->ShowAddPage(
+        provider.extension_id);
     return;
   }
 
   // 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();
   list_empty_ = false;
 }
 
 void VPNListView::AddProviderAndNetworks(
-    const VPNProvider::Key& key,
-    const std::string& name,
+    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_) {
     views::Separator* const separator =
         new views::Separator(views::Separator::HORIZONTAL);
     separator->SetColor(kBorderLightColor);
     container()->AddChildView(separator);
   } else {
     list_empty_ = false;
   }
+  std::string vpn_name =
+      vpn_provider.third_party
+          ? vpn_provider.third_party_provider_name
+          : l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_VPN_BUILT_IN_PROVIDER);
+
   // Add a list entry for the VPN provider.
-  views::View* provider = nullptr;
+  views::View* provider_view = nullptr;
   if (UseMd()) {
-    provider = new VPNListProviderEntryMd(this, name,
-                                          IDS_ASH_STATUS_TRAY_ADD_CONNECTION);
+    provider_view = new VPNListProviderEntryMd(
+        this, vpn_name, IDS_ASH_STATUS_TRAY_ADD_CONNECTION);
   } else {
-    provider = new VPNListProviderEntry(this, name);
+    provider_view = new VPNListProviderEntry(this, vpn_name);
   }
-  container()->AddChildView(provider);
-  provider_view_key_map_[provider] = key;
+  container()->AddChildView(provider_view);
+  provider_view_map_[provider_view] = vpn_provider;
   // Add the networks belonging to this provider, in the priority order returned
   // by shill.
   for (const chromeos::NetworkState* const& network : networks) {
-    if (key.MatchesNetwork(*network))
+    if (VpnProviderMatchesNetwork(vpn_provider, *network))
       AddNetwork(network);
   }
 }
 
 void VPNListView::AddProvidersAndNetworks(
     const chromeos::NetworkStateHandler::NetworkStateList& networks) {
   // Get the list of VPN providers enabled in the primary user's profile.
-  std::vector<VPNProvider> providers = WmShell::Get()
-                                           ->system_tray_delegate()
-                                           ->GetVPNDelegate()
-                                           ->GetVPNProviders();
+  std::vector<VPNProvider> providers =
+      WmShell::Get()->system_tray_delegate()->GetVPNDelegate()->vpn_providers();
 
   // Add providers with at least one configured network along with their
   // networks. Providers are added in the order of their highest priority
   // network.
   for (const chromeos::NetworkState* const& network : networks) {
     for (auto provider = providers.begin(); provider != providers.end();
          ++provider) {
-      if (!provider->key.MatchesNetwork(*network))
+      if (!VpnProviderMatchesNetwork(*provider, *network))
         continue;
-      AddProviderAndNetworks(provider->key, provider->name, networks);
+      AddProviderAndNetworks(*provider, networks);
       providers.erase(provider);
       break;
     }
   }
 
   // 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.key, provider.name, networks);
+    AddProviderAndNetworks(provider, networks);
 }
 
 }  // namespace ash