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..8d542578378f15aaa536fcd06fb781367891cf20
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
@@ -0,0 +1,363 @@
+// 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/base64.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/browser/extensions/api/networking_private/networking_private_crypto.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;
+
+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), using_wifi_service_mock_(false) {
+  Start();
+}
+
+NetworkingPrivateProcessClient::~NetworkingPrivateProcessClient() {}
+
+NetworkingPrivateProcessClient::MessageCallbacks::MessageCallbacks() {}
+
+NetworkingPrivateProcessClient::MessageCallbacks::~MessageCallbacks() {}
+
+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) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  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::Send(IPC::Message* message) {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &NetworkingPrivateProcessClient::SendOnIOThread, this, message));
+}
+
+void NetworkingPrivateProcessClient::SendOnIOThread(IPC::Message* message) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  utility_process_host_->Send(message);
+}
+
+void NetworkingPrivateProcessClient::OnProcessCrashed(int exit_code) {
+  DLOG(ERROR) << __FUNCTION__;
+  std::string error_code("UtilityProcessCrashed");
+  // Report error for all pending callbacks
+  for (IDMap<MessageCallbacks, IDMapOwnPointer>::iterator iter(&callbacks_map_);
+       !iter.IsAtEnd();
+       iter.Advance()) {
+    if (!iter.GetCurrentValue()->error_callback.is_null()) {
+      scoped_ptr<DictionaryValue> error_data_ptr(new DictionaryValue());
+      iter.GetCurrentValue()->error_callback.Run(error_code,
+                                                 error_data_ptr.Pass());
+    }
+  }
+  callbacks_map_.Clear();
+
+  // 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_API_Error, OnApiError)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties_Succeeded,
+                      OnGetPropertiesSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect_Succeeded,
+                      OnStartConnectSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect_Succeeded,
+                      OnStartDisconnectSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties_Succeeded,
+                      OnSetPropertiesSucceeded)
+  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::GetProperties(
+    const std::string& service_path,
+    const DictionaryResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  MessageCallbacks* message_callbacks = new MessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->get_properties_callback = callback;
+
+  Send(new NetworkingPrivateMsg_GetProperties(
+      callbacks_map_.Add(message_callbacks), service_path));
+}
+
+void NetworkingPrivateProcessClient::GetVisibleNetworks(
+    const ListResultCallback& callback) {
+  MessageCallbacks* message_callbacks = new MessageCallbacks();
+  message_callbacks->get_visible_networks_callback = callback;
+
+  Send(new NetworkingPrivateMsg_GetVisibleNetworks(
+      callbacks_map_.Add(message_callbacks)));
+}
+
+// Requests network scan. Broadcasts NetworkListChangedEvent upon completion.
+void NetworkingPrivateProcessClient::RequestNetworkScan() {
+  Send(new NetworkingPrivateMsg_RequestNetworkScan());
+}
+
+void NetworkingPrivateProcessClient::SetProperties(
+    const std::string& service_path,
+    const base::DictionaryValue& properties,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  MessageCallbacks* message_callbacks = new MessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->set_properties_callback = callback;
+
+  scoped_ptr<DictionaryValue> properties_ptr(properties.DeepCopy());
+  Send(new NetworkingPrivateMsg_SetProperties(
+      callbacks_map_.Add(message_callbacks),
+      service_path,
+      *properties_ptr.Pass()));
+}
+
+void NetworkingPrivateProcessClient::StartConnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  MessageCallbacks* message_callbacks = new MessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->start_connect_callback = callback;
+
+  Send(new NetworkingPrivateMsg_StartConnect(
+      callbacks_map_.Add(message_callbacks), service_path));
+}
+
+void NetworkingPrivateProcessClient::StartDisconnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  MessageCallbacks* message_callbacks = new MessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->start_disconnect_callback = callback;
+
+  Send(new NetworkingPrivateMsg_StartDisconnect(
+      callbacks_map_.Add(message_callbacks), service_path));
+}
+
+bool NetworkingPrivateProcessClient::VerifyDestination(
+    const api::VerificationProperties& properties) {
+  if (using_wifi_service_mock_)
+    return true;
+
+  std::vector<std::string> data_parts;
+  data_parts.push_back(properties.device_ssid);
+  data_parts.push_back(properties.device_serial);
+  data_parts.push_back(properties.device_bssid);
+  data_parts.push_back(properties.public_key);
+  data_parts.push_back(properties.nonce);
+  std::string unsigned_data = JoinString(data_parts, ",");
+  std::string signed_data;
+  if (!base::Base64Decode(properties.signed_data, &signed_data))
+    return false;
+  NetworkingPrivateCrypto crypto;
+  return crypto.VerifyCredentials(properties.certificate,
+                                  signed_data,
+                                  unsigned_data,
+                                  properties.device_bssid);
+}
+
+
+bool NetworkingPrivateProcessClient::VerifyAndEncryptData(
+    const api::VerificationProperties& properties,
+    const std::string& plain_data,
+    std::string* encoded_data) {
+  if (using_wifi_service_mock_) {
+    *encoded_data = "encrypted_data";
+    return true;
+  }
+
+  if (!VerifyDestination(properties))
+    return false;
+
+  std::string public_key;
+  if (!base::Base64Decode(properties.public_key, &public_key))
+    return false;
+
+  NetworkingPrivateCrypto crypto;
+  std::string encrypted_data;
+  if (!crypto.EncryptByteString(public_key, plain_data, &encrypted_data))
+    return false;
+
+  return base::Base64Encode(encrypted_data, encoded_data);
+}
+
+void NetworkingPrivateProcessClient::UseWiFiServiceMock(
+    const base::DictionaryValue& parameters) {
+  using_wifi_service_mock_ = true;
+  // Pass mock parameters to utility process itself.
+  scoped_ptr<DictionaryValue> parameters_ptr(parameters.DeepCopy());
+  Send(new NetworkingPrivateMsg_UseWiFiServiceMock_ForTest(
+      *parameters_ptr.Pass()));
+}
+
+// Message handlers
+void NetworkingPrivateProcessClient::OnApiError(
+    int message_id,
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+    if (!message_callbacks->error_callback.is_null())
+      message_callbacks->error_callback.Run(error_code, error_data_ptr.Pass());
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnGetPropertiesSucceeded(
+    int message_id,
+    const std::string& network_guid,
+    const base::DictionaryValue& properties) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    if (!message_callbacks->get_properties_callback.is_null())
+      message_callbacks->get_properties_callback.Run(network_guid, properties);
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnGetVisibleNetworksSucceeded(
+    int message_id,
+    const base::ListValue& network_list) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    if (!message_callbacks->get_visible_networks_callback.is_null())
+      message_callbacks->get_visible_networks_callback.Run(network_list);
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+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());
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesSucceeded(
+    int message_id,
+    const std::string& network_guid) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    if (!message_callbacks->set_properties_callback.is_null())
+      message_callbacks->set_properties_callback.Run();
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnStartConnectSucceeded(
+    int message_id,
+    const std::string& network_guid) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    if (!message_callbacks->start_connect_callback.is_null())
+      message_callbacks->start_connect_callback.Run();
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectSucceeded(
+    int message_id,
+    const std::string& network_guid) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    if (!message_callbacks->start_disconnect_callback.is_null())
+      message_callbacks->start_disconnect_callback.Run();
+    callbacks_map_.Remove(message_id);
+  }
+}
+