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..544d27f66bd47b3ca230504806a57a3263e5f520
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
@@ -0,0 +1,415 @@
+// Copyright 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/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/api/networking_private/networking_private_crypto.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;
+using extensions::api::networking_private::VerificationProperties;
+
+namespace extensions {
+
+// Interface for Verify* methods implementation.
+class NetworkingPrivateProcessClient::CryptoVerify {
+ public:
+  virtual bool VerifyDestination(const VerificationProperties& properties) = 0;
+
+  virtual bool VerifyAndEncryptData(const VerificationProperties& properties,
+                                    const std::string& plain_data,
+                                    std::string* encoded_data) = 0;
+};
+
+namespace {
+// Mock Verify* methods implementation to satisfy expectations of
+// networking_private_apitest.
+// TODO(mef): Fix ChromeOS implementation to use NetworkingPrivateCrypto,
+// and update networking_private_apitest to use and expect valid data.
+// That will eliminate the need for mock implementation.
+class CryptoVerifyMock : public NetworkingPrivateProcessClient::CryptoVerify {
+  virtual bool VerifyDestination(
+      const VerificationProperties& properties) OVERRIDE {
+    return true;
+  }
+
+  virtual bool VerifyAndEncryptData(const VerificationProperties& properties,
+                                    const std::string& plain_data,
+                                    std::string* encoded_data) OVERRIDE {
+    *encoded_data = "encrypted_data";
+    return true;
+  }
+};
+
+// Implementation of Verify* methods using NetworkingPrivateCrypto.
+class CryptoVerifyImpl : public NetworkingPrivateProcessClient::CryptoVerify {
+  virtual bool VerifyDestination(
+      const VerificationProperties& properties) OVERRIDE {
+    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);
+  }
+
+  virtual bool VerifyAndEncryptData(const VerificationProperties& properties,
+                                    const std::string& plain_data,
+                                    std::string* encoded_data) OVERRIDE {
+    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);
+  }
+};
+
+}  // namespace
+
+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));
+    client->Start();
+  }
+
+  return scoped_refptr<NetworkingPrivateProcessClient>(
+      base::UserDataAdapter<NetworkingPrivateProcessClient>::Get(
+          profile, kNetworkingPrivateProcessClient));
+}
+
+NetworkingPrivateProcessClient::NetworkingPrivateProcessClient(Profile* profile)
+    : profile_(profile), crypto_verify_(new CryptoVerifyImpl()) {}
+
+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));
+  if (utility_process_host_.get())
+    utility_process_host_->Send(message);
+}
+
+void NetworkingPrivateProcessClient::OnProcessCrashed(int exit_code) {
+  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.
+  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 = AddMessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->get_properties_callback = callback;
+
+  Send(new NetworkingPrivateMsg_GetProperties(message_callbacks->id,
+                                              service_path));
+}
+
+void NetworkingPrivateProcessClient::GetVisibleNetworks(
+    const ListResultCallback& callback) {
+  MessageCallbacks* message_callbacks = AddMessageCallbacks();
+  message_callbacks->get_visible_networks_callback = callback;
+
+  Send(new NetworkingPrivateMsg_GetVisibleNetworks(message_callbacks->id));
+}
+
+// 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 = AddMessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->set_properties_callback = callback;
+
+  scoped_ptr<DictionaryValue> properties_ptr(properties.DeepCopy());
+  Send(new NetworkingPrivateMsg_SetProperties(
+      message_callbacks->id, service_path, *properties_ptr.Pass()));
+}
+
+void NetworkingPrivateProcessClient::StartConnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  MessageCallbacks* message_callbacks = AddMessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->start_connect_callback = callback;
+
+  Send(new NetworkingPrivateMsg_StartConnect(message_callbacks->id,
+                                             service_path));
+}
+
+void NetworkingPrivateProcessClient::StartDisconnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  MessageCallbacks* message_callbacks = AddMessageCallbacks();
+  message_callbacks->error_callback = error_callback;
+  message_callbacks->start_disconnect_callback = callback;
+
+  Send(new NetworkingPrivateMsg_StartDisconnect(message_callbacks->id,
+                                                service_path));
+}
+
+bool NetworkingPrivateProcessClient::VerifyDestination(
+    const VerificationProperties& properties) {
+  return crypto_verify_->VerifyDestination(properties);
+}
+
+bool NetworkingPrivateProcessClient::VerifyAndEncryptData(
+    const VerificationProperties& properties,
+    const std::string& plain_data,
+    std::string* encoded_data) {
+  return crypto_verify_->VerifyAndEncryptData(
+      properties, plain_data, encoded_data);
+}
+
+void NetworkingPrivateProcessClient::UseWiFiServiceMock(
+    const base::DictionaryValue& parameters) {
+  // Use mock CryptoVerify implementation.
+  crypto_verify_.reset(new CryptoVerifyMock());
+  // Pass mock parameters to utility process itself.
+  scoped_ptr<DictionaryValue> parameters_ptr(parameters.DeepCopy());
+  Send(new NetworkingPrivateMsg_UseWiFiServiceMock_ForTest(
+      *parameters_ptr.Pass()));
+}
+
+NetworkingPrivateProcessClient::MessageCallbacks*
+NetworkingPrivateProcessClient::AddMessageCallbacks() {
+  MessageCallbacks* message_callbacks = new MessageCallbacks();
+  message_callbacks->process_client = this;
+  message_callbacks->id = callbacks_map_.Add(message_callbacks);
+  return message_callbacks;
+}
+
+// Message handlers
+void NetworkingPrivateProcessClient::OnApiError(
+    MessageCallbacksID message_id,
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    DCHECK(!message_callbacks->error_callback.is_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(
+    MessageCallbacksID message_id,
+    const std::string& network_guid,
+    const base::DictionaryValue& properties) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    DCHECK(!message_callbacks->get_properties_callback.is_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(
+    MessageCallbacksID message_id,
+    const base::ListValue& network_list) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    DCHECK(!message_callbacks->get_visible_networks_callback.is_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::networking_private::OnNetworksChanged::Create(network_guids));
+  scoped_ptr<extensions::Event> netchanged_event(new extensions::Event(
+      api::networking_private::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::networking_private::OnNetworkListChanged::Create(network_guids));
+  scoped_ptr<extensions::Event> netlistchanged_event(new extensions::Event(
+      api::networking_private::OnNetworkListChanged::kEventName, args.Pass()));
+  event_router->BroadcastEvent(netlistchanged_event.Pass());
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesSucceeded(
+    MessageCallbacksID message_id,
+    const std::string& network_guid) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    DCHECK(!message_callbacks->set_properties_callback.is_null());
+    if (!message_callbacks->set_properties_callback.is_null())

[tbarzic, 2013/10/15 21:06:52]

you don't need if when you have DCHECK

[cbentzel, 2013/10/16 14:17:40]

I think it's safer to do the runtime null-check code (and remove the DCHECK) -
not really any security guarantees for IPC so it may have an invalid message_id
or one not associated with set_properties_callback.

So - I'd just remove the DHCECK's.

[mef, 2013/10/17 02:33:25]

Done.

+      message_callbacks->set_properties_callback.Run();
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnStartConnectSucceeded(
+    MessageCallbacksID message_id,
+    const std::string& network_guid) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    DCHECK(!message_callbacks->start_connect_callback.is_null());
+    if (!message_callbacks->start_connect_callback.is_null())
+      message_callbacks->start_connect_callback.Run();
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectSucceeded(
+    MessageCallbacksID message_id,
+    const std::string& network_guid) {
+  MessageCallbacks* message_callbacks = callbacks_map_.Lookup(message_id);
+  if (message_callbacks != NULL) {
+    DCHECK(!message_callbacks->start_disconnect_callback.is_null());
+    if (!message_callbacks->start_disconnect_callback.is_null())
+      message_callbacks->start_disconnect_callback.Run();
+    callbacks_map_.Remove(message_id);
+  }
+}
+
+}  // namespace extensions