Add networkingPrivate.getThirdPartyVpnProviderList

extensions/browser/api/networking_private/networking_private_api.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_api.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "components/onc/onc_constants.h"
 #include "extensions/browser/api/networking_private/networking_private_delegate.h"
 #include "extensions/browser/api/networking_private/networking_private_delegate_factory.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/common/api/networking_private.h"
 
 namespace {
 
-const int kDefaultNetworkListLimit = 1000;
-
 extensions::NetworkingPrivateDelegate* GetDelegate(
     content::BrowserContext* browser_context) {
   return extensions::NetworkingPrivateDelegateFactory::GetForBrowserContext(
       browser_context);
 }
 
 }  // namespace
 
 namespace extensions {
 
 namespace private_api = api::networking_private;
 
 namespace networking_private {
 
-// static
+const int kDefaultNetworkListLimit = 1000;
 const char kErrorInvalidNetworkGuid[] = "Error.InvalidNetworkGuid";
 const char kErrorInvalidNetworkOperation[] = "Error.InvalidNetworkOperation";
 const char kErrorNetworkUnavailable[] = "Error.NetworkUnavailable";
 const char kErrorEncryptionError[] = "Error.EncryptionError";
 const char kErrorNotReady[] = "Error.NotReady";
 const char kErrorNotSupported[] = "Error.NotSupported";
 const char kErrorSimLocked[] = "Error.SimLocked";
 
 }  // namespace networking_private
 
@@ skipping 194 matching lines @@
 bool NetworkingPrivateGetNetworksFunction::RunAsync() {
   scoped_ptr<private_api::GetNetworks::Params> params =
       private_api::GetNetworks::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   std::string network_type = private_api::ToString(params->filter.network_type);
   const bool configured_only =
       params->filter.configured ? *params->filter.configured : false;
   const bool visible_only =
       params->filter.visible ? *params->filter.visible : false;
-  const int limit =
-      params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit;
+  const int limit = params->filter.limit

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

orthogonal change?

+                        ? *params->filter.limit
+                        : networking_private::kDefaultNetworkListLimit;
 
   GetDelegate(browser_context())
       ->GetNetworks(
           network_type, configured_only, visible_only, limit,
           base::Bind(&NetworkingPrivateGetNetworksFunction::Success, this),
           base::Bind(&NetworkingPrivateGetNetworksFunction::Failure, this));
   return true;
 }
 
 void NetworkingPrivateGetNetworksFunction::Success(
@@ skipping 18 matching lines @@
   scoped_ptr<private_api::GetVisibleNetworks::Params> params =
       private_api::GetVisibleNetworks::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   std::string network_type = private_api::ToString(params->network_type);
   const bool configured_only = false;
   const bool visible_only = true;
 
   GetDelegate(browser_context())
       ->GetNetworks(
-          network_type, configured_only, visible_only, kDefaultNetworkListLimit,
+          network_type, configured_only, visible_only,
+          networking_private::kDefaultNetworkListLimit,
           base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Success,
                      this),
           base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Failure,
                      this));
   return true;
 }
 
 void NetworkingPrivateGetVisibleNetworksFunction::Success(
     scoped_ptr<base::ListValue> network_properties_list) {
   SetResult(network_properties_list.release());
@@ skipping 463 matching lines @@
 void NetworkingPrivateSetCellularSimStateFunction::Success() {
   SendResponse(true);
 }
 
 void NetworkingPrivateSetCellularSimStateFunction::Failure(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// NetworkingPrivateGetThirdPartyVPNProvidersFunction
+
+NetworkingPrivateGetThirdPartyVPNProvidersFunction::
+    ~NetworkingPrivateGetThirdPartyVPNProvidersFunction() {}
+
+bool NetworkingPrivateGetThirdPartyVPNProvidersFunction::RunAsync() {
+  scoped_ptr<base::ListValue> vpn_provider_list =
+      GetDelegate(browser_context())->GetThirdPartyVpnProviderList();
+  SetResult(vpn_provider_list.release());
+  SendResponse(true);
+  return true;
+}
+
 }  // namespace extensions