Base infrastructure for Networking Private API on Windows and Mac.

chrome/browser/extensions/api/networking_private/networking_private_process_client.cc

Index: chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc b/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e6c9ec6a517ee5509ac1609790e095eefb5f9e18
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
@@ -0,0 +1,350 @@
+// Copyright (c) 2012 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_private/networking_private_process_client.h"
+
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/event_router.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/api/networking_private.h"
+#include "chrome/common/networking_private_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/utility_process_host.h"
+
+using content::BrowserThread;
+using content::UtilityProcessHost;
+namespace api = extensions::api::networking_private;
+
+const char kNetworkingPrivateProcessClient[] = "NetworkingPrivateProcessClient";
+
+scoped_refptr<NetworkingPrivateProcessClient>
+NetworkingPrivateProcessClient::GetProcessClientForProfile(Profile* profile) {
+  if (!profile->GetUserData(kNetworkingPrivateProcessClient)) {
+    NetworkingPrivateProcessClient* client =
+        new NetworkingPrivateProcessClient(profile);
+    profile->SetUserData(
+        kNetworkingPrivateProcessClient,
+        new base::UserDataAdapter<NetworkingPrivateProcessClient>(client));
+  }
+
+  return scoped_refptr<NetworkingPrivateProcessClient>(
+      base::UserDataAdapter<NetworkingPrivateProcessClient>::Get(
+          profile, kNetworkingPrivateProcessClient));
+}
+
+NetworkingPrivateProcessClient::NetworkingPrivateProcessClient(Profile* profile)
+    : profile_(profile) {
+  Start();
+}
+
+NetworkingPrivateProcessClient::~NetworkingPrivateProcessClient() {}
+
+void NetworkingPrivateProcessClient::Start() {
+  BrowserThread::ID thread_id;
+  CHECK(BrowserThread::GetCurrentThreadIdentifier(&thread_id));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::StartProcessOnIOThread,
+                 this,
+                 thread_id));
+}
+
+void NetworkingPrivateProcessClient::StartProcessOnIOThread(
+    BrowserThread::ID thread_id) {
+  utility_process_host_ = UtilityProcessHost::Create(
+      this, BrowserThread::GetMessageLoopProxyForThread(thread_id).get())
+                              ->AsWeakPtr();
+  utility_process_host_->DisableSandbox();
+  utility_process_host_->StartBatchMode();
+}
+
+void NetworkingPrivateProcessClient::ShutdownProcessClient() {
+  profile_->RemoveUserData(kNetworkingPrivateProcessClient);
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::ShutdownProcessOnIOThread,
+                 this));
+}
+
+void NetworkingPrivateProcessClient::ShutdownProcessOnIOThread() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // The utility_process_host_ will take care of deleting itself.
+  if (utility_process_host_.get()) {
+    utility_process_host_->EndBatchMode();
+    utility_process_host_.reset();
+  }
+}
+
+void NetworkingPrivateProcessClient::OnProcessCrashed(int exit_code) {
+  DLOG(ERROR) << __FUNCTION__;
+  std::string error_code("UtilityProcessCrashed");
+  scoped_ptr<DictionaryValue> error_data_ptr(new DictionaryValue());
+  if (!error_callback_.is_null())
+    error_callback_.Run(error_code, error_data_ptr.Pass());
+  // restart the utility process.
+  utility_process_host_.reset();
+  Start();
+}
+
+bool NetworkingPrivateProcessClient::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(NetworkingPrivateProcessClient, message)
+  // Responses from NetworkingPrivateHandler.
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties_Succeeded,
+                      OnGetPropertiesSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties_Failed,
+                      OnGetPropertiesFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect_Succeeded,
+                      OnStartConnectSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect_Failed,
+                      OnStartConnectFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect_Succeeded,
+                      OnStartDisconnectSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect_Failed,
+                      OnStartDisconnectFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties_Succeeded,
+                      OnSetPropertiesSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties_Failed,
+                      OnSetPropertiesFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetVisibleNetworksSucceeded,
+                      OnGetVisibleNetworksSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_NetworksChanged_Event,
+                      OnNetworksChangedEvent)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_NetworkListChanged_Event,
+                      OnNetworkListChangedEvent)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void NetworkingPrivateProcessClient::UseWiFiServiceMock(
+    const base::DictionaryValue& parameters) {
+  // Preserve mock parameters in client instance.
+  wifi_service_mock_parameters_.reset(parameters.DeepCopy());
+  // Also pass them to utility process itself.
+  scoped_ptr<DictionaryValue> parameters_ptr(parameters.DeepCopy());
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnUseWiFiServiceMockStart,
+                 this,
+                 base::Passed(&parameters_ptr)));
+}
+
+void NetworkingPrivateProcessClient::OnUseWiFiServiceMockStart(
+    scoped_ptr<base::DictionaryValue> parameters) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_UseWiFiServiceMock(*parameters));
+}
+
+void NetworkingPrivateProcessClient::GetProperties(
+    const std::string& service_path,
+    const DictionaryResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  get_properties_success_callback_map_[service_path] = callback;
+  error_callback_ = error_callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnGetPropertiesStart,
+                 this,
+                 service_path));
+}
+
+// Message handlers
+void NetworkingPrivateProcessClient::OnGetPropertiesStart(
+    const std::string& network_guid) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_GetProperties(network_guid));
+}
+
+void NetworkingPrivateProcessClient::OnGetPropertiesSucceeded(
+    const std::string& network_guid,
+    const base::DictionaryValue& properties) {
+  std::map<std::string, DictionaryResultCallback>::iterator callback =
+      get_properties_success_callback_map_.find(network_guid);
+  if (callback != get_properties_success_callback_map_.end()) {
+    callback->second.Run(network_guid, properties);
+    get_properties_success_callback_map_.erase(callback);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnGetPropertiesFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!error_callback_.is_null())
+    error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+// Requests network scan. Broadcasts NetworkListChangedEvent upon completion.
+void NetworkingPrivateProcessClient::RequestNetworkScan() {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnRequestNetworkScan, this));
+}
+
+void NetworkingPrivateProcessClient::OnRequestNetworkScan() {
+  utility_process_host_->Send(new NetworkingPrivateMsg_RequestNetworkScan());
+}
+
+void NetworkingPrivateProcessClient::GetVisibleNetworks(
+    const ListResultCallback& callback) {
+  get_visible_networks_callback_ = callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnGetVisibleNetworks, this));
+}
+
+void NetworkingPrivateProcessClient::OnGetVisibleNetworks() {
+  utility_process_host_->Send(new NetworkingPrivateMsg_GetVisibleNetworks());
+}
+
+void NetworkingPrivateProcessClient::OnGetVisibleNetworksSucceeded(
+    const base::ListValue& network_list) {
+  if (!get_visible_networks_callback_.is_null())
+    get_visible_networks_callback_.Run(network_list);
+}
+
+void NetworkingPrivateProcessClient::StartConnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  start_connect_success_callback_ = callback;
+  error_callback_ = error_callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnStartConnectStart,
+                 this,
+                 service_path));
+}
+
+// Message handlers
+void NetworkingPrivateProcessClient::OnStartConnectStart(
+    const std::string& network_guid) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_StartConnect(network_guid));
+}
+
+void NetworkingPrivateProcessClient::OnStartConnectSucceeded(
+    const std::string& network_guid) {
+  if (!start_connect_success_callback_.is_null())
+    start_connect_success_callback_.Run();
+}
+
+void NetworkingPrivateProcessClient::OnStartConnectFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!error_callback_.is_null())
+    error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+void NetworkingPrivateProcessClient::StartDisconnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  start_disconnect_success_callback_ = callback;
+  error_callback_ = error_callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnStartDisconnectStart,
+                 this,
+                 service_path));
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectStart(
+    const std::string& network_guid) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_StartDisconnect(network_guid));
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectSucceeded(
+    const std::string& network_guid) {
+  if (!start_disconnect_success_callback_.is_null())
+    start_disconnect_success_callback_.Run();
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!error_callback_.is_null())
+    error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+void NetworkingPrivateProcessClient::SetProperties(
+    const std::string& service_path,
+    const base::DictionaryValue& properties,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  set_properties_success_callback_ = callback;
+  error_callback_ = error_callback;
+  scoped_ptr<DictionaryValue> properties_ptr(properties.DeepCopy());
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnSetPropertiesStart,
+                 this,
+                 service_path,
+                 base::Passed(&properties_ptr)));
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesStart(
+    const std::string& network_guid,
+    scoped_ptr<base::DictionaryValue> properties) {
+  LOG(INFO) << *properties;
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_SetProperties(network_guid, *properties));
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesSucceeded(
+    const std::string& network_guid) {
+  if (!set_properties_success_callback_.is_null())
+    set_properties_success_callback_.Run();
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!error_callback_.is_null())
+    error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+void NetworkingPrivateProcessClient::OnNetworksChangedEvent(
+    const std::vector<std::string>& network_guids) {
+  extensions::EventRouter* event_router =
+      extensions::ExtensionSystem::Get(profile_)->event_router();
+  scoped_ptr<base::ListValue> args(
+      api::OnNetworksChanged::Create(network_guids));
+  scoped_ptr<extensions::Event> netchanged_event(
+      new extensions::Event(api::OnNetworksChanged::kEventName, args.Pass()));
+  event_router->BroadcastEvent(netchanged_event.Pass());
+}
+
+void NetworkingPrivateProcessClient::OnNetworkListChangedEvent(
+    const std::vector<std::string>& network_guids) {
+  extensions::EventRouter* event_router =
+      extensions::ExtensionSystem::Get(profile_)->event_router();
+  scoped_ptr<base::ListValue> args(
+      api::OnNetworkListChanged::Create(network_guids));
+  scoped_ptr<extensions::Event> netlistchanged_event(new extensions::Event(
+      api::OnNetworkListChanged::kEventName, args.Pass()));
+  event_router->BroadcastEvent(netlistchanged_event.Pass());
+}