Add networkingPrivate.getThirdPartyVpnProviderList

extensions/browser/api/networking_private/networking_private_chromeos.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 "extensions/browser/api/networking_private/networking_private_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #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;
 using chromeos::NetworkHandler;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
 using extensions::NetworkingPrivateDelegate;
 
 namespace private_api = extensions::api::networking_private;
@@ skipping 76 matching lines @@
   DCHECK_NE(private_api::DEVICE_STATE_TYPE_NONE, state);
   scoped_ptr<private_api::DeviceStateProperties> properties(
       new private_api::DeviceStateProperties);
   properties->type = private_api::ParseNetworkType(type);
   properties->state = state;
   if (device && state == private_api::DEVICE_STATE_TYPE_ENABLED)
     properties->scanning.reset(new bool(device->scanning()));
   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,
     scoped_ptr<base::DictionaryValue> error_data) {
   callback.Run(error_name);
 }
 
 void RequirePinSuccess(
     const std::string& device_path,
     const std::string& current_pin,
     const std::string& new_pin,
     const extensions::NetworkingPrivateChromeOS::VoidCallback& success_callback,
     const extensions::NetworkingPrivateChromeOS::FailureCallback&
         failure_callback) {
   // After RequirePin succeeds, call ChangePIN iff a different new_pin is
   // provided.
   if (new_pin.empty() || new_pin == current_pin) {
     success_callback.Run();
     return;
   }
   NetworkHandler::Get()->network_device_handler()->ChangePin(
       device_path, current_pin, new_pin, success_callback,
       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
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context,
     scoped_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(verify_delegate.Pass()),
       browser_context_(browser_context),
       weak_ptr_factory_(this) {}
 
 NetworkingPrivateChromeOS::~NetworkingPrivateChromeOS() {
 }
 
 void NetworkingPrivateChromeOS::GetProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->GetProperties(
       service_path,
-      base::Bind(&NetworkHandlerDictionaryCallback, success_callback),
+      base::Bind(&NetworkingPrivateChromeOS::GetPropertiesCallback,
+                 weak_ptr_factory_.GetWeakPtr(), success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetManagedProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   std::string user_id_hash;
   if (!GetUserIdHash(browser_context_, &user_id_hash, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   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,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
@@ skipping 63 matching lines @@
     const std::string& network_type,
     bool configured_only,
     bool visible_only,
     int limit,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
   NetworkTypePattern pattern =
       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());
 }
 
 void NetworkingPrivateChromeOS::StartConnect(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
@@ skipping 252 matching lines @@
       pattern, false, chromeos::network_handler::ErrorCallback());
 
   return true;
 }
 
 bool NetworkingPrivateChromeOS::RequestScan() {
   GetStateHandler()->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