Introduce networking.cast API

chrome/browser/extensions/api/networking_cast/chrome_networking_cast_delegate.cc

Index: chrome/browser/extensions/api/networking_cast/chrome_networking_cast_delegate.cc
diff --git a/chrome/browser/extensions/api/networking_cast/chrome_networking_cast_delegate.cc b/chrome/browser/extensions/api/networking_cast/chrome_networking_cast_delegate.cc
new file mode 100644
index 0000000000000000000000000000000000000000..74f48bbad2132b5613e80633c1b485e43a09e40e
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_cast/chrome_networking_cast_delegate.cc
@@ -0,0 +1,84 @@
+// Copyright 2017 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 "chrome/browser/extensions/api/networking_cast/chrome_networking_cast_delegate.h"
+
+#include "base/callback.h"
+#include "chrome/browser/extensions/api/networking_private/networking_private_verify_delegate_factory_impl.h"
+#include "extensions/common/api/networking_cast.h"
+#include "extensions/common/api/networking_private.h"
+
+namespace private_api = extensions::api::networking_private;
+namespace cast_api = extensions::api::networking_cast;
+
+namespace extensions {
+
+namespace {
+
+ChromeNetworkingCastDelegate::FactoryCallback* g_factory_callback = nullptr;
+
+std::unique_ptr<private_api::VerificationProperties>
+AsPrivateApiVerificaitonProperties(
+    const cast_api::VerificationProperties& properties) {
+  std::unique_ptr<base::DictionaryValue> cast_properties_dict =
+      properties.ToValue();
+  CHECK(cast_properties_dict);
+  return private_api::VerificationProperties::FromValue(*cast_properties_dict);

[Devlin, 2017/03/13 05:21:49]

If these are exactly the same, could we use a reference to
networking.cast.VerificationProperties in networkingPrivate to avoid this
method?

[stevenjb, 2017/03/13 17:12:26]

Originally this was a much larger CL that did this, and I suggested separating
out the networkingPrivate changes to a follow up CL. I'm a little (probably
overly) nervous about changes to networkingPrivate breaking Chrome OS packaged
apps and I felt that a more incremental change would be better.

That said, since this only affects Cast, It should be fine to go ahead and move
VerificationProperties to networkingCast in this CL. I does seem like it would
be less than ideal to move it later. Apologies for the churn.

[tbarzic, 2017/03/13 22:35:01]

Actually, I'm not sure that would work well, and extensions that have
networkingPrivate API might not have permission to use networking.cast API (and
thus types in networking.cast). This can be worked around (e.g. enabling
networking.cast when networkingPrivate permission is present), but I think it
would be cleaner from the API perspective to have different types.

I'll try to get rid of this step when I move VerifyDelegate logic to
NetworkingCAstDelegate, e.g. by making the delegate interface independent of the
networking API

+}
+
+}  // namespace
+
+std::unique_ptr<ChromeNetworkingCastDelegate>
+ChromeNetworkingCastDelegate::Create() {
+  if (g_factory_callback)
+    return g_factory_callback->Run();
+  return std::unique_ptr<ChromeNetworkingCastDelegate>(
+      new ChromeNetworkingCastDelegate(
+          NetworkingPrivateVerifyDelegateFactoryImpl().CreateDelegate()));
+}
+
+void ChromeNetworkingCastDelegate::SetFactoryCallbackForTest(
+    FactoryCallback* factory_callback) {
+  g_factory_callback = factory_callback;
+}
+
+ChromeNetworkingCastDelegate::ChromeNetworkingCastDelegate(
+    std::unique_ptr<NetworkingPrivateDelegate::VerifyDelegate> crypto_verify)
+    : crypto_verify_(std::move(crypto_verify)) {}
+
+ChromeNetworkingCastDelegate::~ChromeNetworkingCastDelegate() {}
+
+void ChromeNetworkingCastDelegate::VerifyDestination(
+    const cast_api::VerificationProperties& properties,
+    const VerifiedCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  std::unique_ptr<private_api::VerificationProperties> private_api_properties =
+      AsPrivateApiVerificaitonProperties(properties);
+  crypto_verify_->VerifyDestination(*private_api_properties, success_callback,
+                                    failure_callback);
+}
+
+void ChromeNetworkingCastDelegate::VerifyAndEncryptCredentials(
+    const std::string& guid,
+    const api::networking_cast::VerificationProperties& properties,
+    const DataCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  std::unique_ptr<private_api::VerificationProperties> private_api_properties =
+      AsPrivateApiVerificaitonProperties(properties);
+  crypto_verify_->VerifyAndEncryptCredentials(
+      guid, *private_api_properties, success_callback, failure_callback);
+}
+
+void ChromeNetworkingCastDelegate::VerifyAndEncryptData(
+    const std::string& data,
+    const api::networking_cast::VerificationProperties& properties,
+    const DataCallback& success_callback,
+    const FailureCallback& failure_callback) {
+  std::unique_ptr<private_api::VerificationProperties> private_api_properties =
+      AsPrivateApiVerificaitonProperties(properties);
+  crypto_verify_->VerifyAndEncryptData(*private_api_properties, data,
+                                       success_callback, failure_callback);
+}
+
+}  // namespace extensions