Introduce networking.cast API

extensions/browser/api/networking_cast/networking_cast_api.cc

Index: extensions/browser/api/networking_cast/networking_cast_api.cc
diff --git a/extensions/browser/api/networking_cast/networking_cast_api.cc b/extensions/browser/api/networking_cast/networking_cast_api.cc
new file mode 100644
index 0000000000000000000000000000000000000000..db8deb6fbe5e4f858ca26f1f2dd92f4a4425ef93
--- /dev/null
+++ b/extensions/browser/api/networking_cast/networking_cast_api.cc
@@ -0,0 +1,186 @@
+// 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 "extensions/browser/api/networking_cast/networking_cast_api.h"
+
+#include "base/bind.h"
+#include "extensions/browser/api/extensions_api_client.h"
+#include "extensions/browser/api/networking_cast/networking_cast_delegate.h"
+#include "extensions/common/api/networking_cast.h"
+
+#if defined(OS_CHROMEOS)
+#include "chromeos/network/network_device_handler.h"
+#include "chromeos/network/network_handler.h"
+#endif
+
+namespace extensions {
+
+NetworkingCastVerifyDestinationFunction::
+    ~NetworkingCastVerifyDestinationFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastVerifyDestinationFunction::Run() {
+  std::unique_ptr<api::networking_cast::VerifyDestination::Params> params =
+      api::networking_cast::VerifyDestination::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  NetworkingCastDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastDelegate();
+  if (!delegate)
+    return RespondNow(Error("Not supported."));

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

Why is the API compiled on unsupported platforms?

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

Done.

+
+  delegate->VerifyDestination(
+      params->properties,
+      base::Bind(&NetworkingCastVerifyDestinationFunction::Success, this),
+      base::Bind(&NetworkingCastVerifyDestinationFunction::Failure, this));
+  return did_respond() ? AlreadyResponded() : RespondLater();
+}
+
+void NetworkingCastVerifyDestinationFunction::Success(bool result) {
+  Respond(ArgumentList(
+      api::networking_cast::VerifyDestination::Results::Create(result)));
+}
+
+void NetworkingCastVerifyDestinationFunction::Failure(
+    const std::string& error) {
+  Respond(Error(error));
+}
+
+NetworkingCastVerifyAndEncryptCredentialsFunction::
+    ~NetworkingCastVerifyAndEncryptCredentialsFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastVerifyAndEncryptCredentialsFunction::Run() {
+  std::unique_ptr<api::networking_cast::VerifyAndEncryptCredentials::Params>
+      params =
+          api::networking_cast::VerifyAndEncryptCredentials::Params::Create(
+              *args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  NetworkingCastDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastDelegate();
+  if (!delegate)
+    return RespondNow(Error("Not supported."));
+
+  delegate->VerifyAndEncryptCredentials(
+      params->network_guid, params->properties,
+      base::Bind(&NetworkingCastVerifyAndEncryptCredentialsFunction::Success,
+                 this),
+      base::Bind(&NetworkingCastVerifyAndEncryptCredentialsFunction::Failure,
+                 this));
+  return did_respond() ? AlreadyResponded() : RespondLater();

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

Can these respond synchronously?  If so, we should comment that explicitly.  If
not, we shouldn't be using this pattern.

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

Yes, it can respond synchronously, in tests.

+}
+
+void NetworkingCastVerifyAndEncryptCredentialsFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(
+      api::networking_cast::VerifyAndEncryptCredentials::Results::Create(
+          result)));
+}
+
+void NetworkingCastVerifyAndEncryptCredentialsFunction::Failure(
+    const std::string& error) {
+  Respond(Error(error));
+}
+
+NetworkingCastVerifyAndEncryptDataFunction::
+    ~NetworkingCastVerifyAndEncryptDataFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastVerifyAndEncryptDataFunction::Run() {
+  std::unique_ptr<api::networking_cast::VerifyAndEncryptData::Params> params =
+      api::networking_cast::VerifyAndEncryptData::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  NetworkingCastDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastDelegate();
+  if (!delegate)
+    return RespondNow(Error("Not supported."));
+
+  delegate->VerifyAndEncryptData(
+      params->data, params->properties,
+      base::Bind(&NetworkingCastVerifyAndEncryptDataFunction::Success, this),
+      base::Bind(&NetworkingCastVerifyAndEncryptDataFunction::Failure, this));
+  return did_respond() ? AlreadyResponded() : RespondLater();
+}
+
+void NetworkingCastVerifyAndEncryptDataFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(
+      api::networking_cast::VerifyAndEncryptData::Results::Create(result)));
+}
+
+void NetworkingCastVerifyAndEncryptDataFunction::Failure(
+    const std::string& error) {
+  Respond(Error(error));
+}
+
+NetworkingCastSetWifiTDLSEnabledStateFunction::
+    ~NetworkingCastSetWifiTDLSEnabledStateFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastSetWifiTDLSEnabledStateFunction::Run() {
+  std::unique_ptr<api::networking_cast::SetWifiTDLSEnabledState::Params>
+      params =
+          api::networking_cast::SetWifiTDLSEnabledState::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+#if defined(OS_CHROMEOS)
+  chromeos::NetworkHandler::Get()->network_device_handler()->SetWifiTDLSEnabled(
+      params->ip_or_mac_address, params->enabled,
+      base::Bind(&NetworkingCastSetWifiTDLSEnabledStateFunction::Success, this),
+      base::Bind(&NetworkingCastSetWifiTDLSEnabledStateFunction::Failure,
+                 this));
+  return did_respond() ? AlreadyResponded() : RespondLater();
+#else
+  return RespondNow(Error("Not supported"));
+#endif
+}
+
+void NetworkingCastSetWifiTDLSEnabledStateFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(
+      api::networking_cast::SetWifiTDLSEnabledState::Results::Create(
+          api::networking_cast::ParseTDLSStatus(result))));
+}
+
+void NetworkingCastSetWifiTDLSEnabledStateFunction::Failure(
+    const std::string& error,
+    std::unique_ptr<base::DictionaryValue> error_data) {
+  Respond(Error(error));
+}
+
+NetworkingCastGetWifiTDLSStatusFunction::
+    ~NetworkingCastGetWifiTDLSStatusFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastGetWifiTDLSStatusFunction::Run() {
+  std::unique_ptr<api::networking_cast::GetWifiTDLSStatus::Params> params =
+      api::networking_cast::GetWifiTDLSStatus::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+#if defined(OS_CHROMEOS)
+  chromeos::NetworkHandler::Get()->network_device_handler()->GetWifiTDLSStatus(
+      params->ip_or_mac_address,
+      base::Bind(&NetworkingCastGetWifiTDLSStatusFunction::Success, this),
+      base::Bind(&NetworkingCastGetWifiTDLSStatusFunction::Failure, this));
+  return did_respond() ? AlreadyResponded() : RespondLater();
+#else
+  return RespondNow(Error("Not supported"));
+#endif
+}
+
+void NetworkingCastGetWifiTDLSStatusFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(api::networking_cast::GetWifiTDLSStatus::Results::Create(
+      api::networking_cast::ParseTDLSStatus(result))));
+}
+
+void NetworkingCastGetWifiTDLSStatusFunction::Failure(
+    const std::string& error,
+    std::unique_ptr<base::DictionaryValue> error_data) {
+  Respond(Error(error));
+}
+
+}  // namespace extensions