Base infrastructure for Networking Private API on Windows and Mac.

chrome/utility/networking_private_handler.cc

+// Copyright (c) 2013 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/utility/networking_private_handler.h"
+
+#include "base/bind.h"
+#include "base/json/json_reader.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/threading/thread.h"
+#include "chrome/common/networking_private_messages.h"
+#include "content/public/utility/utility_thread.h"
+
+namespace chrome {
+
+NetworkingPrivateHandler::NetworkingPrivateHandler()
+    : wifi_service_(WiFiService::CreateServiceMock()) {}
+
+NetworkingPrivateHandler::~NetworkingPrivateHandler() {}
+
+bool NetworkingPrivateHandler::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(NetworkingPrivateHandler, message)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties, OnGetPropertiesStart)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties, OnSetPropertiesStart)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect, OnStartConnectStart)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect,
+                      OnStartDisconnectStart)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetVisibleNetworks,
+                      OnGetVisibleNetworks)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_RequestNetworkScan,
+                      OnRequestNetworkScan)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void NetworkingPrivateHandler::OnGetPropertiesStart(
+    const std::string& network_guid) {
+  wifi_service_->GetProperties(
+      network_guid,
+      base::Bind(&NetworkingPrivateHandler::OnGetPropertiesSucceeded,
+                 base::Unretained(this)),
+      base::Bind(&NetworkingPrivateHandler::OnGetPropertiesFailed,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnGetPropertiesSucceeded(
+    const std::string& network_guid,
+    const WiFiService::NetworkProperties& properties) {
+  scoped_ptr<DictionaryValue> properties_value(properties.ToValue(false));
+  Send(new NetworkingPrivateMsg_GetProperties_Succeeded(network_guid,
+                                                        *properties_value));
+}
+
+void NetworkingPrivateHandler::OnGetPropertiesFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  Send(new NetworkingPrivateMsg_GetProperties_Failed(error_name, *error_data));
+}
+
+void NetworkingPrivateHandler::OnSetPropertiesStart(
+    const std::string& network_guid,
+    const base::DictionaryValue& properties) {
+  wifi_service_->SetProperties(
+      network_guid,
+      properties,
+      base::Bind(&NetworkingPrivateHandler::OnSetPropertiesSucceeded,
+                 base::Unretained(this)),
+      base::Bind(&NetworkingPrivateHandler::OnSetPropertiesFailed,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnSetPropertiesSucceeded(
+    const std::string& network_guid) {
+  Send(new NetworkingPrivateMsg_SetProperties_Succeeded(network_guid));
+}
+
+void NetworkingPrivateHandler::OnSetPropertiesFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  Send(new NetworkingPrivateMsg_SetProperties_Failed(error_name, *error_data));
+}
+
+void NetworkingPrivateHandler::OnStartConnectStart(
+    const std::string& network_guid) {
+  wifi_service_->StartConnect(
+      network_guid,
+      base::Bind(&NetworkingPrivateHandler::OnStartConnectSucceeded,
+                 base::Unretained(this)),
+      base::Bind(&NetworkingPrivateHandler::OnStartConnectFailed,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnStartConnectSucceeded(
+    const std::string& network_guid) {
+  Send(new NetworkingPrivateMsg_StartConnect_Succeeded(network_guid));
+  std::vector<std::string> networks_list(1, network_guid);
+  Send(new NetworkingPrivateMsg_NetworksChanged_Event(networks_list));
+
+  // Generate NetworkListChanged event.
+  OnRequestNetworkScan();
+}
+
+void NetworkingPrivateHandler::OnStartConnectFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  Send(new NetworkingPrivateMsg_StartConnect_Failed(error_name, *error_data));
+}
+
+void NetworkingPrivateHandler::OnStartDisconnectStart(
+    const std::string& network_guid) {
+  wifi_service_->StartDisconnect(
+      network_guid,
+      base::Bind(&NetworkingPrivateHandler::OnStartDisconnectSucceeded,
+                 base::Unretained(this)),
+      base::Bind(&NetworkingPrivateHandler::OnStartDisconnectFailed,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnStartDisconnectSucceeded(
+    const std::string& network_guid) {
+  Send(new NetworkingPrivateMsg_StartDisconnect_Succeeded(network_guid));
+  std::vector<std::string> networks_list(1, network_guid);
+  Send(new NetworkingPrivateMsg_NetworksChanged_Event(networks_list));
+}
+
+void NetworkingPrivateHandler::OnStartDisconnectFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  Send(
+      new NetworkingPrivateMsg_StartDisconnect_Failed(error_name, *error_data));
+}
+
+void NetworkingPrivateHandler::OnRequestNetworkScan() {
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&NetworkingPrivateHandler::OnNetworkScanSucceeded,
+                 base::Unretained(this)),
+      base::Bind(&NetworkingPrivateHandler::OnNetworkScanFailed,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnNetworkScanSucceeded(
+    const WiFiService::NetworkList& network_list) {
+  std::vector<std::string> list;
+  for (WiFiService::NetworkList::const_iterator it = network_list.begin();
+       it != network_list.end();
+       ++it) {
+    list.push_back(it->guid);
+  }
+
+  Send(new NetworkingPrivateMsg_NetworkListChanged_Event(list));
+}
+
+void NetworkingPrivateHandler::OnNetworkScanFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {}
+
+void NetworkingPrivateHandler::OnGetVisibleNetworks() {
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&NetworkingPrivateHandler::OnGetVisibleNetworksSucceeded,
+                 base::Unretained(this)),
+      base::Bind(&NetworkingPrivateHandler::OnGetVisibleNetworksFailed,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnGetVisibleNetworksSucceeded(
+    const WiFiService::NetworkList& network_list) {
+  scoped_ptr<ListValue> visible_networks(new ListValue());
+  for (WiFiService::NetworkList::const_iterator it = network_list.begin();
+       it != network_list.end();
+       ++it) {
+    scoped_ptr<DictionaryValue> network(it->ToValue(true));
+    visible_networks->Append(network.release());
+  }
+
+  Send(new NetworkingPrivateMsg_GetVisibleNetworksSucceeded(*visible_networks));
+}
+
+void NetworkingPrivateHandler::OnGetVisibleNetworksFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {}
+
+// static
+bool NetworkingPrivateHandler::Send(IPC::Message* message) {
+  return content::UtilityThread::Get()->Send(message);
+}
+
+}  // namespace chrome