Base infrastructure for Networking Private API on Windows and Mac.

chrome/utility/networking_private_handler.cc

Index: chrome/utility/networking_private_handler.cc
diff --git a/chrome/utility/networking_private_handler.cc b/chrome/utility/networking_private_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..da18db4a584b6f36fee41befe106ccc64cec39e2
--- /dev/null
+++ b/chrome/utility/networking_private_handler.cc
@@ -0,0 +1,214 @@
+// 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::CreateService()) {
+  wifi_service_->SetNetworksChangedObserver(
+      base::Bind(&NetworkingPrivateHandler::OnNetworksChangedEvent,
+                 base::Unretained(this)));
+  wifi_service_->SetNetworkListChangedObserver(
+      base::Bind(&NetworkingPrivateHandler::OnNetworkListChangedEvent,
+                 base::Unretained(this)));
+}
+
+NetworkingPrivateHandler::~NetworkingPrivateHandler() {}
+
+bool NetworkingPrivateHandler::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(NetworkingPrivateHandler, message)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_UseWiFiServiceMock,
+                      OnUseWiFiServiceMock)
+  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::OnUseWiFiServiceMock(
+    const base::DictionaryValue& parameters) {
+  wifi_service_.reset(WiFiService::CreateServiceMock());
+  wifi_service_->SetNetworksChangedObserver(
+      base::Bind(&NetworkingPrivateHandler::OnNetworksChangedEvent,
+                 base::Unretained(this)));
+  wifi_service_->SetNetworkListChangedObserver(
+      base::Bind(&NetworkingPrivateHandler::OnNetworkListChangedEvent,
+                 base::Unretained(this)));
+}
+
+void NetworkingPrivateHandler::OnApiError(
+    int message_id,
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  Send(new NetworkingPrivateMsg_API_Error(message_id, error_name, *error_data));
+}
+
+void NetworkingPrivateHandler::OnGetPropertiesStart(
+    int message_id,
+    const std::string& network_guid) {
+  wifi_service_->GetProperties(
+      network_guid,
+      base::Bind(&NetworkingPrivateHandler::OnGetPropertiesSucceeded,
+                 base::Unretained(this),
+                 message_id),
+      base::Bind(&NetworkingPrivateHandler::OnApiError,
+                 base::Unretained(this),
+                 message_id));
+}
+
+void NetworkingPrivateHandler::OnGetPropertiesSucceeded(
+    int message_id,
+    const std::string& network_guid,
+    const WiFiService::NetworkProperties& properties) {
+  scoped_ptr<DictionaryValue> properties_value(properties.ToValue(false));
+  Send(new NetworkingPrivateMsg_GetProperties_Succeeded(
+      message_id, network_guid, *properties_value));
+}
+
+void NetworkingPrivateHandler::OnSetPropertiesStart(
+    int message_id,
+    const std::string& network_guid,
+    const base::DictionaryValue& properties) {
+  wifi_service_->SetProperties(
+      network_guid,
+      properties,
+      base::Bind(&NetworkingPrivateHandler::OnSetPropertiesSucceeded,
+                 base::Unretained(this),
+                 message_id),
+      base::Bind(&NetworkingPrivateHandler::OnApiError,
+                 base::Unretained(this),
+                 message_id));
+}
+
+void NetworkingPrivateHandler::OnSetPropertiesSucceeded(
+    int message_id,
+    const std::string& network_guid) {
+  Send(new NetworkingPrivateMsg_SetProperties_Succeeded(message_id,
+                                                        network_guid));
+}
+
+void NetworkingPrivateHandler::OnStartConnectStart(
+    int message_id,
+    const std::string& network_guid) {
+  wifi_service_->StartConnect(
+      network_guid,
+      base::Bind(&NetworkingPrivateHandler::OnStartConnectSucceeded,
+                 base::Unretained(this),
+                 message_id),
+      base::Bind(&NetworkingPrivateHandler::OnApiError,
+                 base::Unretained(this),
+                 message_id));
+}
+
+void NetworkingPrivateHandler::OnStartConnectSucceeded(
+    int message_id,
+    const std::string& network_guid) {
+  Send(new NetworkingPrivateMsg_StartConnect_Succeeded(message_id,
+                                                       network_guid));
+}
+
+void NetworkingPrivateHandler::OnStartDisconnectStart(
+    int message_id,
+    const std::string& network_guid) {
+  wifi_service_->StartDisconnect(
+      network_guid,
+      base::Bind(&NetworkingPrivateHandler::OnStartDisconnectSucceeded,
+                 base::Unretained(this),
+                 message_id),
+      base::Bind(&NetworkingPrivateHandler::OnApiError,
+                 base::Unretained(this),
+                 message_id));
+}
+
+void NetworkingPrivateHandler::OnStartDisconnectSucceeded(
+    int message_id,
+    const std::string& network_guid) {
+  Send(new NetworkingPrivateMsg_StartDisconnect_Succeeded(message_id,
+                                                          network_guid));
+}
+
+void NetworkingPrivateHandler::OnRequestNetworkScan() {
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&NetworkingPrivateHandler::OnNetworkScanSucceeded,
+                 base::Unretained(this)),
+      base::Bind(
+          &NetworkingPrivateHandler::OnApiError, base::Unretained(this), 0));
+  wifi_service_->RequestNetworkScan();
+}
+
+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::OnGetVisibleNetworks(int message_id) {
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&NetworkingPrivateHandler::OnGetVisibleNetworksSucceeded,
+                 base::Unretained(this),
+                 message_id),
+      base::Bind(&NetworkingPrivateHandler::OnApiError,
+                 base::Unretained(this),
+                 message_id));
+}
+
+void NetworkingPrivateHandler::OnGetVisibleNetworksSucceeded(
+    int message_id,
+    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(message_id,
+                                                            *visible_networks));
+}
+
+// static
+bool NetworkingPrivateHandler::Send(IPC::Message* message) {
+  return content::UtilityThread::Get()->Send(message);
+}
+
+void NetworkingPrivateHandler::OnNetworkListChangedEvent(
+    const WiFiService::NetworkGuidList& network_guid_list) {
+  std::vector<std::string> networks(network_guid_list.begin(),
+                                    network_guid_list.end());
+  Send(new NetworkingPrivateMsg_NetworkListChanged_Event(networks));
+}
+
+void NetworkingPrivateHandler::OnNetworksChangedEvent(
+    const WiFiService::NetworkGuidList& network_guid_list) {
+  std::vector<std::string> networks(network_guid_list.begin(),
+                                    network_guid_list.end());
+  Send(new NetworkingPrivateMsg_NetworksChanged_Event(networks));
+}

[stevenjb, 2013/09/25 19:09:15]

WS

[mef, 2013/10/08 21:46:26]

Done.

+}  // namespace chrome
+