Introduce networking.cast API

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

+// 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/networking_cast_api.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "chrome/common/extensions/api/networking_cast.h"
+#include "extensions/browser/api/extensions_api_client.h"
+#include "extensions/browser/api/networking_private/networking_cast_delegate.h"
+
+#if defined(OS_CHROMEOS)
+#include "chromeos/network/network_device_handler.h"
+#include "chromeos/network/network_handler.h"
+#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
+#endif
+
+namespace private_api = extensions::api::networking_private;
+namespace cast_api = extensions::api::networking_cast;
+
+namespace extensions {
+
+namespace {
+
+#if defined(OS_CHROMEOS)
+// Parses TDLS status returned by network handler to networking_cast TDLS status
+// type.
+cast_api::TDLSStatus ParseTDLSStatus(const std::string& status) {
+  if (status == shill::kTDLSConnectedState)
+    return cast_api::TDLS_STATUS_CONNECTED;
+  if (status == shill::kTDLSNonexistentState)
+    return cast_api::TDLS_STATUS_NONEXISTENT;
+  if (status == shill::kTDLSDisabledState)
+    return cast_api::TDLS_STATUS_DISABLED;
+  if (status == shill::kTDLSDisconnectedState)
+    return cast_api::TDLS_STATUS_DISCONNECTED;
+  if (status == shill::kTDLSUnknownState)
+    return cast_api::TDLS_STATUS_UNKNOWN;
+
+  NOTREACHED() << "Unknown TDLS status " << status;
+  return cast_api::TDLS_STATUS_UNKNOWN;
+}
+#endif
+
+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);
+}
+
+}  // namespace
+
+NetworkingCastVerifyDestinationFunction::
+    ~NetworkingCastVerifyDestinationFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastVerifyDestinationFunction::Run() {
+  std::unique_ptr<cast_api::VerifyDestination::Params> params =
+      cast_api::VerifyDestination::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  NetworkingCastDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastDelegate();
+  std::unique_ptr<private_api::VerificationProperties> private_api_properties =
+      AsPrivateApiVerificaitonProperties(params->properties);
+  delegate->VerifyDestination(
+      *private_api_properties,
+      base::Bind(&NetworkingCastVerifyDestinationFunction::Success, this),
+      base::Bind(&NetworkingCastVerifyDestinationFunction::Failure, this));
+
+  // VerifyDestination might respond synchronously, e.g. in tests.
+  return did_respond() ? AlreadyResponded() : RespondLater();
+}
+
+void NetworkingCastVerifyDestinationFunction::Success(bool result) {
+  Respond(ArgumentList(cast_api::VerifyDestination::Results::Create(result)));
+}
+
+void NetworkingCastVerifyDestinationFunction::Failure(
+    const std::string& error) {
+  Respond(Error(error));
+}
+
+NetworkingCastVerifyAndEncryptCredentialsFunction::
+    ~NetworkingCastVerifyAndEncryptCredentialsFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastVerifyAndEncryptCredentialsFunction::Run() {
+  std::unique_ptr<cast_api::VerifyAndEncryptCredentials::Params> params =
+      cast_api::VerifyAndEncryptCredentials::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  NetworkingCastDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastDelegate();
+  std::unique_ptr<private_api::VerificationProperties> private_api_properties =
+      AsPrivateApiVerificaitonProperties(params->properties);
+  delegate->VerifyAndEncryptCredentials(
+      params->network_guid, *private_api_properties,
+      base::Bind(&NetworkingCastVerifyAndEncryptCredentialsFunction::Success,
+                 this),
+      base::Bind(&NetworkingCastVerifyAndEncryptCredentialsFunction::Failure,
+                 this));
+
+  // VerifyAndEncryptCredentials might respond synchronously, e.g. in tests.
+  return did_respond() ? AlreadyResponded() : RespondLater();
+}
+
+void NetworkingCastVerifyAndEncryptCredentialsFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(
+      cast_api::VerifyAndEncryptCredentials::Results::Create(result)));
+}
+
+void NetworkingCastVerifyAndEncryptCredentialsFunction::Failure(
+    const std::string& error) {
+  Respond(Error(error));
+}
+
+NetworkingCastVerifyAndEncryptDataFunction::
+    ~NetworkingCastVerifyAndEncryptDataFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastVerifyAndEncryptDataFunction::Run() {
+  std::unique_ptr<cast_api::VerifyAndEncryptData::Params> params =
+      cast_api::VerifyAndEncryptData::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  NetworkingCastDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetNetworkingCastDelegate();
+  std::unique_ptr<private_api::VerificationProperties> private_api_properties =
+      AsPrivateApiVerificaitonProperties(params->properties);
+  delegate->VerifyAndEncryptData(
+      params->data, *private_api_properties,
+      base::Bind(&NetworkingCastVerifyAndEncryptDataFunction::Success, this),
+      base::Bind(&NetworkingCastVerifyAndEncryptDataFunction::Failure, this));
+
+  // VerifyAndEncryptData might respond synchronously, e.g. in tests.
+  return did_respond() ? AlreadyResponded() : RespondLater();
+}
+
+void NetworkingCastVerifyAndEncryptDataFunction::Success(
+    const std::string& result) {
+  Respond(
+      ArgumentList(cast_api::VerifyAndEncryptData::Results::Create(result)));
+}
+
+void NetworkingCastVerifyAndEncryptDataFunction::Failure(
+    const std::string& error) {
+  Respond(Error(error));
+}
+
+NetworkingCastSetWifiTDLSEnabledStateFunction::
+    ~NetworkingCastSetWifiTDLSEnabledStateFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastSetWifiTDLSEnabledStateFunction::Run() {
+  std::unique_ptr<cast_api::SetWifiTDLSEnabledState::Params> params =
+      cast_api::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));
+
+  // SetWifiTDLSEnabled might respond synchronously, e.g. in tests.
+  return did_respond() ? AlreadyResponded() : RespondLater();
+#else
+  return RespondNow(Error("Not supported"));
+#endif
+}
+
+#if defined(OS_CHROMEOS)
+void NetworkingCastSetWifiTDLSEnabledStateFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(cast_api::SetWifiTDLSEnabledState::Results::Create(
+      ParseTDLSStatus(result))));
+}
+
+void NetworkingCastSetWifiTDLSEnabledStateFunction::Failure(
+    const std::string& error,
+    std::unique_ptr<base::DictionaryValue> error_data) {
+  Respond(Error(error));
+}
+#endif
+
+NetworkingCastGetWifiTDLSStatusFunction::
+    ~NetworkingCastGetWifiTDLSStatusFunction() {}
+
+ExtensionFunction::ResponseAction
+NetworkingCastGetWifiTDLSStatusFunction::Run() {
+  std::unique_ptr<cast_api::GetWifiTDLSStatus::Params> params =
+      cast_api::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));
+
+  // GetWifiTDLSStatus might respond synchronously, e.g. in tests.
+  return did_respond() ? AlreadyResponded() : RespondLater();
+#else
+  return RespondNow(Error("Not supported"));
+#endif
+}
+
+#if defined(OS_CHROMEOS)
+void NetworkingCastGetWifiTDLSStatusFunction::Success(
+    const std::string& result) {
+  Respond(ArgumentList(
+      cast_api::GetWifiTDLSStatus::Results::Create(ParseTDLSStatus(result))));
+}
+
+void NetworkingCastGetWifiTDLSStatusFunction::Failure(
+    const std::string& error,
+    std::unique_ptr<base::DictionaryValue> error_data) {
+  Respond(Error(error));
+}
+#endif
+
+}  // namespace extensions