Add networkingPrivate.getThirdPartyVpnProviderList

extensions/browser/api/networking_private/networking_private_chromeos.cc

Index: extensions/browser/api/networking_private/networking_private_chromeos.cc
diff --git a/extensions/browser/api/networking_private/networking_private_chromeos.cc b/extensions/browser/api/networking_private/networking_private_chromeos.cc
index 006d09ea7861335bde50aaefe21a9190c647909c..75b73f411b8319a012e2a1fd570559099e6fffec 100644
--- a/extensions/browser/api/networking_private/networking_private_chromeos.cc
+++ b/extensions/browser/api/networking_private/networking_private_chromeos.cc
@@ -26,7 +26,12 @@
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_set.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "extensions/common/permissions/permissions_data.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using chromeos::DeviceState;
@@ -123,14 +128,6 @@ void AppendDeviceState(
   device_state_list->push_back(properties.Pass());
 }
 
-void NetworkHandlerDictionaryCallback(
-    const NetworkingPrivateDelegate::DictionaryCallback& callback,
-    const std::string& service_path,
-    const base::DictionaryValue& dictionary) {
-  scoped_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
-  callback.Run(dictionary_copy.Pass());
-}
-
 void NetworkHandlerFailureCallback(
     const NetworkingPrivateDelegate::FailureCallback& callback,
     const std::string& error_name,
@@ -156,6 +153,20 @@ void RequirePinSuccess(
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
+// Returns the string corresponding to |key|. If the property is a managed
+// dictionary, returns the active value. If the property does not exist or
+// has no active value, returns an empty string.
+std::string GetStringFromDictionary(const base::DictionaryValue& dictionary,
+                                    const std::string& key) {
+  std::string result;
+  if (!dictionary.GetString(key, &result)) {
+    const base::DictionaryValue* managed = nullptr;
+    if (dictionary.GetDictionary(key, &managed))
+      managed->GetString(::onc::kAugmentationActiveSetting, &result);
+  }
+  return result;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -184,7 +195,8 @@ void NetworkingPrivateChromeOS::GetProperties(
 
   GetManagedConfigurationHandler()->GetProperties(
       service_path,
-      base::Bind(&NetworkHandlerDictionaryCallback, success_callback),
+      base::Bind(&NetworkingPrivateChromeOS::GetPropertiesCallback,
+                 weak_ptr_factory_.GetWeakPtr(), success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
@@ -206,10 +218,54 @@ void NetworkingPrivateChromeOS::GetManagedProperties(
 
   GetManagedConfigurationHandler()->GetManagedProperties(
       user_id_hash, service_path,
-      base::Bind(&NetworkHandlerDictionaryCallback, success_callback),
+      base::Bind(&NetworkingPrivateChromeOS::GetPropertiesCallback,
+                 weak_ptr_factory_.GetWeakPtr(), success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
+void NetworkingPrivateChromeOS::GetPropertiesCallback(
+    const NetworkingPrivateDelegate::DictionaryCallback& callback,
+    const std::string& service_path,
+    const base::DictionaryValue& dictionary) {
+  scoped_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
+
+  std::string type =
+      GetStringFromDictionary(dictionary, ::onc::network_config::kType);
+
+  if (type == ::onc::network_config::kVPN)
+    AppendThirdPartyProviderName(dictionary_copy.get());
+
+  callback.Run(dictionary_copy.Pass());
+}
+
+// Populate ThirdPartyVPN.kName with the provider name for third-party VPNs.
+void NetworkingPrivateChromeOS::AppendThirdPartyProviderName(
+    base::DictionaryValue* dictionary) {
+  base::DictionaryValue* vpn_dict = nullptr;
+  if (!dictionary->GetDictionary(::onc::network_config::kVPN, &vpn_dict))
+    return;
+  if (GetStringFromDictionary(*vpn_dict, ::onc::vpn::kType) !=
+      ::onc::vpn::kThirdPartyVpn)
+    return;
+  base::DictionaryValue* third_party_vpn = nullptr;
+  if (!vpn_dict->GetDictionary(::onc::vpn::kThirdPartyVpn, &third_party_vpn))
+    return;
+
+  std::string extension_id = GetStringFromDictionary(
+      *third_party_vpn, ::onc::third_party_vpn::kExtensionID);
+  const ExtensionSet& extensions =
+      ExtensionRegistry::Get(browser_context_)->enabled_extensions();
+  for (const auto& extension : extensions) {
+    if (extension->permissions_data()->HasAPIPermission(
+            APIPermission::kVpnProvider) &&
+        extension->id() == extension_id) {
+      third_party_vpn->SetStringWithoutPathExpansion(
+          ::onc::third_party_vpn::kName, extension->name());
+      break;
+    }
+  }
+}
+
 void NetworkingPrivateChromeOS::GetState(
     const std::string& guid,
     const DictionaryCallback& success_callback,
@@ -293,7 +349,7 @@ void NetworkingPrivateChromeOS::GetNetworks(
       chromeos::onc::NetworkTypePatternFromOncType(network_type);
   scoped_ptr<base::ListValue> network_properties_list =
       chromeos::network_util::TranslateNetworkListToONC(
-          pattern, configured_only, visible_only, limit, false /* debugging */);
+          pattern, configured_only, visible_only, limit);
   success_callback.Run(network_properties_list.Pass());
 }
 
@@ -566,4 +622,29 @@ bool NetworkingPrivateChromeOS::RequestScan() {
   return true;
 }
 
+scoped_ptr<base::ListValue>
+NetworkingPrivateChromeOS::GetThirdPartyVpnProviderList() {
+  scoped_ptr<ThirdPartyVPNPropertyList> vpn_provider_list(
+      new ThirdPartyVPNPropertyList);
+  const ExtensionSet& extensions =
+      ExtensionRegistry::Get(browser_context_)->enabled_extensions();
+  for (const auto& extension : extensions) {
+    if (!extension->permissions_data()->HasAPIPermission(
+            APIPermission::kVpnProvider)) {
+      continue;
+    }
+    linked_ptr<private_api::ThirdPartyVPNProperties> provider(
+        new private_api::ThirdPartyVPNProperties);
+    provider->extension_id = extension->id();
+    provider->name.reset(new std::string(extension->name()));

[pneubeck (no reviews), 2015/08/13 12:58:37]

why not using
 https://developer.chrome.com/extensions/management#method-get
in the extension?
I.e.
  chrome.management.get(vpn_provider.ExtensionID, function(info) {
    vpn_provider_name = info.name
  });

that also allows to get other information of that extension, like short name or
the icon,

+    vpn_provider_list->push_back(provider);
+  }
+
+  scoped_ptr<base::ListValue> vpn_provider_list_value(new base::ListValue);
+  for (const auto& provider : *vpn_provider_list)
+    vpn_provider_list_value->Append(provider->ToValue().release());
+
+  return vpn_provider_list_value.Pass();
+}
+
 }  // namespace extensions