Move NetworkingPrivateDelegate::CryptoVerify to networking_cast_private

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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/memory/ptr_util.h"
 #include "components/onc/onc_constants.h"
+#include "extensions/browser/api/extensions_api_client.h"
+#include "extensions/browser/api/networking_private/networking_cast_private_delegate.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"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/features/feature_provider.h"
 
 namespace extensions {
 
 namespace {
@@ skipping 19 matching lines @@
 
 bool CanChangeSharedConfig(const Extension* extension,
                            Feature::Context context) {
 #if defined(OS_CHROMEOS)
   return context == Feature::WEBUI_CONTEXT;
 #else
   return true;
 #endif
 }
 
+std::unique_ptr<NetworkingCastPrivateDelegate::Credentials> AsCastCredentials(
+    api::networking_private::VerificationProperties& properties) {
+  return base::MakeUnique<NetworkingCastPrivateDelegate::Credentials>(
+      properties.certificate,
+      properties.intermediate_certificates
+          ? *properties.intermediate_certificates
+          : std::vector<std::string>(),
+      properties.signed_data, properties.device_ssid, properties.device_serial,
+      properties.device_bssid, properties.public_key, properties.nonce);
+}
+
 }  // namespace
 
 namespace private_api = api::networking_private;
 
 namespace networking_private {
 
 // static
 const char kErrorAccessToSharedConfig[] = "Error.CannotChangeSharedConfig";
 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 kErrorPolicyControlled[] = "Error.PolicyControlled";
 const char kErrorSimLocked[] = "Error.SimLocked";
 
 }  // namespace networking_private
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetPropertiesFunction
 
@@ skipping 518 matching lines @@
   // http://crbug.com/678737
   if (!HasPrivateNetworkingAccess(extension(), source_context_type(),
                                   source_url())) {
     return RespondNow(Error(kPrivateOnlyError));
   }
 
   std::unique_ptr<private_api::VerifyDestination::Params> params =
       private_api::VerifyDestination::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  GetDelegate(browser_context())
-      ->VerifyDestination(
-          params->properties,
-          base::Bind(&NetworkingPrivateVerifyDestinationFunction::Success,
-                     this),
-          base::Bind(&NetworkingPrivateVerifyDestinationFunction::Failure,
-                     this));
+  NetworkingCastPrivateDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastPrivateDelegate();
+  if (!delegate)
+    return RespondNow(Error("Not supported."));
+
+  delegate->VerifyDestination(
+      AsCastCredentials(params->properties),
+      base::Bind(&NetworkingPrivateVerifyDestinationFunction::Success, this),
+      base::Bind(&NetworkingPrivateVerifyDestinationFunction::Failure, this));
   // Success() or Failure() might have been called synchronously at this point.
   // In that case this function has already called Respond(). Return
   // AlreadyResponded() in that case.
   return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void NetworkingPrivateVerifyDestinationFunction::Success(bool result) {
   Respond(
       ArgumentList(private_api::VerifyDestination::Results::Create(result)));
 }
@@ skipping 17 matching lines @@
   // TODO(tbarzic): Consider exposing this via separate API.
   // http://crbug.com/678737
   if (!HasPrivateNetworkingAccess(extension(), source_context_type(),
                                   source_url())) {
     return RespondNow(Error(kPrivateOnlyError));
   }
   std::unique_ptr<private_api::VerifyAndEncryptCredentials::Params> params =
       private_api::VerifyAndEncryptCredentials::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  GetDelegate(browser_context())
-      ->VerifyAndEncryptCredentials(
-          params->network_guid, params->properties,
-          base::Bind(
-              &NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
-              this),
-          base::Bind(
-              &NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
-              this));
+  NetworkingCastPrivateDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastPrivateDelegate();
+  if (!delegate)
+    return RespondNow(Error("Not supported."));
+
+  delegate->VerifyAndEncryptCredentials(
+      params->network_guid, AsCastCredentials(params->properties),
+      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
+                 this),
+      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
+                 this));
   // Success() or Failure() might have been called synchronously at this point.
   // In that case this function has already called Respond(). Return
   // AlreadyResponded() in that case.
   return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success(
     const std::string& result) {
   Respond(ArgumentList(
       private_api::VerifyAndEncryptCredentials::Results::Create(result)));
@@ skipping 18 matching lines @@
   // TODO(tbarzic): Consider exposing this via separate API.
   // http://crbug.com/678737
   if (!HasPrivateNetworkingAccess(extension(), source_context_type(),
                                   source_url())) {
     return RespondNow(Error(kPrivateOnlyError));
   }
   std::unique_ptr<private_api::VerifyAndEncryptData::Params> params =
       private_api::VerifyAndEncryptData::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  GetDelegate(browser_context())
-      ->VerifyAndEncryptData(
-          params->properties, params->data,
-          base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Success,
-                     this),
-          base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Failure,
-                     this));
+  NetworkingCastPrivateDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastPrivateDelegate();
+  if (!delegate)
+    return RespondNow(Error("Not supported."));
+
+  delegate->VerifyAndEncryptData(
+      params->data, AsCastCredentials(params->properties),
+      base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Success, this),
+      base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Failure,
+                 this));
   // Success() or Failure() might have been called synchronously at this point.
   // In that case this function has already called Respond(). Return
   // AlreadyResponded() in that case.
   return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void NetworkingPrivateVerifyAndEncryptDataFunction::Success(
     const std::string& result) {
   Respond(
       ArgumentList(private_api::VerifyAndEncryptData::Results::Create(result)));
@@ skipping 215 matching lines @@
   // private_api::GlobalPolicy is a subset of the global policy dictionary
   // (by definition), so use the api setter/getter to generate the subset.
   std::unique_ptr<private_api::GlobalPolicy> policy(
       private_api::GlobalPolicy::FromValue(*policy_dict));
   DCHECK(policy);
   return RespondNow(
       ArgumentList(private_api::GetGlobalPolicy::Results::Create(*policy)));
 }
 
 }  // namespace extensions