Base infrastructure for Networking Private API on Windows and Mac.

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

Index: chrome/browser/extensions/api/networking_private/networking_private_process_client.h
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_process_client.h b/chrome/browser/extensions/api/networking_private/networking_private_process_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..52201ac5553694be06def6fbde61e0bd42cbb6d8
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_private/networking_private_process_client.h
@@ -0,0 +1,244 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_PROCESS_CLIENT_H_
+#define CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_PROCESS_CLIENT_H_
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/id_map.h"
+#include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
+#include "base/strings/string16.h"
+#include "base/supports_user_data.h"
+#include "base/values.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/utility_process_host.h"
+#include "content/public/browser/utility_process_host_client.h"
+
+class Profile;
+
+namespace extensions {
+
+namespace api {
+namespace networking_private {
+struct VerificationProperties;
+}  // namespace networking_private
+}  // namespace api
+
+// This class is the client for the out-of-process networkingPrivate handler.
+class NetworkingPrivateProcessClient
+    : public content::UtilityProcessHostClient {
+ public:
+  // Interface for Verify* methods implementation.
+  class CryptoVerify {
+   public:
+    virtual bool VerifyDestination(
+        const api::networking_private::VerificationProperties& properties) = 0;
+
+    virtual bool VerifyAndEncryptData(
+        const api::networking_private::VerificationProperties& properties,
+        const std::string& plain_data,
+        std::string* encoded_data) = 0;
+  };
+
+  // Interface for observing Network Events.
+  class Observer {
+   public:
+    virtual void OnNetworksChangedEvent(
+        const std::vector<std::string>& network_guids) = 0;
+    virtual void OnNetworkListChangedEvent(
+        const std::vector<std::string>& network_guids) = 0;
+  };
+
+  // An error callback used by most of API functions to receive error results
+  // from the NetworkingPrivateProcessClient.
+  typedef base::Callback<
+      void(const std::string& error_name,
+           scoped_ptr<base::DictionaryValue> error_data)> ErrorCallback;
+
+  // An error callback used by most of Crypto Verify* API functions to receive
+  // error results from the NetworkingPrivateProcessClient.
+  typedef base::Callback<
+      void(const std::string& error_name,
+           const std::string& error)> CryptoErrorCallback;
+
+  // Callback used to return bool result from VerifyDestination function.
+  typedef base::Callback<void(bool result)> BoolResultCallback;
+
+  // Callback used to return string result from VerifyAndEncryptData function.
+  typedef base::Callback<void(const std::string& result)> StringResultCallback;
+
+  // Callback used to return Dictionary of network properties.
+  typedef base::Callback<
+      void(const std::string& network_guid,
+           const base::DictionaryValue& dictionary)> DictionaryResultCallback;
+
+  // Callback used to return List of visibile networks.
+  typedef base::Callback<
+      void(const base::ListValue& network_list)> ListResultCallback;
+
+  // Callback used to notify API function of completed API call without data.
+  typedef base::Callback<void()> VoidResultCallback;
+
+  explicit NetworkingPrivateProcessClient(Profile* profile);
+
+  // Gets the properties of the network with id |service_path|. See note on
+  // |callback| and |error_callback|, in class description above.
+  void GetProperties(const std::string& service_path,
+                     const DictionaryResultCallback& callback,
+                     const ErrorCallback& error_callback);
+
+  // Start connect to the network with id |service_path|. See note on
+  // |callback| and |error_callback|, in class description above.
+  void StartConnect(const std::string& service_path,
+                    const VoidResultCallback& callback,
+                    const ErrorCallback& error_callback);
+
+  // Start disconnect from the network with id |service_path|. See note on
+  // |callback| and |error_callback|, in class description above.
+  void StartDisconnect(const std::string& service_path,
+                       const VoidResultCallback& callback,
+                       const ErrorCallback& error_callback);
+
+  // Sets the |properties| of the network with id |service_path|. See note on
+  // |callback| and |error_callback|, in class description above.
+  void SetProperties(const std::string& service_path,
+                     const base::DictionaryValue& properties,
+                     const VoidResultCallback& callback,
+                     const ErrorCallback& error_callback);
+
+  // Requests network scan. Broadcasts NetworkListChangedEvent upon completion.
+  void RequestNetworkScan();
+
+  // Gets the list of visible networks and calls |callback|.
+  void GetVisibleNetworks(const ListResultCallback& callback);
+
+  void VerifyDestination(

[cbentzel, 2013/10/21 21:07:16]

Note: It's also a little strange to have VerifyDestination and
VerifyAndEncryptData be part of this class's interface, as they don't actually
involve communication to the utility process. Don't change it for this CL, but
consider moving these out to a separate class which the
networking_private_api_nonchromeos uses. 

[mef, 2013/10/21 23:29:16]

Will do, especially considering that they could be used for chromeos as well.

+      scoped_ptr<base::ListValue> args,

[tbarzic, 2013/10/21 21:54:07]

nit: can this be moved to the same line as VerifyDestination

[mef, 2013/10/21 23:29:16]

Done.

+      const BoolResultCallback& callback,
+      const CryptoErrorCallback& error_callback);
+
+  void VerifyAndEncryptData(
+      scoped_ptr<base::ListValue> args,

[tbarzic, 2013/10/21 21:54:07]

ditto

[mef, 2013/10/21 23:29:16]

Done.

+      const StringResultCallback& callback,
+      const CryptoErrorCallback& error_callback);
+
+  // Adds observer to network events.
+  void AddObserver(Observer* network_events_observer);
+
+  // Removes observer to network events. If there is no observers,
+  // then process can be shut down when there are no more calls pending return.
+  void RemoveObserver(Observer* network_events_observer);
+
+  // Switches Utility Process to use WiFiServiceMock for browser_tests and
+  // mock CryptoVerify implementation.
+  void SetupForTest(const base::DictionaryValue& parameters,
+                    CryptoVerify* crypto_verify_mock);
+
+  // Gets a NetworkingPrivateProcessClient instances, creating one if it
+  // doesn't exist.
+  static scoped_refptr<NetworkingPrivateProcessClient>
+      GetForProfile(Profile* profile);
+
+ private:
+  // Callbacks to run when reply message is received from UtilityProcess.
+  typedef int32 MessageCallbacksID;
+  struct MessageCallbacks {
+    MessageCallbacks();
+    ~MessageCallbacks();
+
+    DictionaryResultCallback get_properties_callback;
+    VoidResultCallback start_connect_callback;
+    VoidResultCallback start_disconnect_callback;
+    VoidResultCallback set_properties_callback;
+    ListResultCallback get_visible_networks_callback;
+    ErrorCallback error_callback;
+
+    MessageCallbacksID id;
+    scoped_refptr<NetworkingPrivateProcessClient> process_client;

[cbentzel, 2013/10/21 21:07:16]

I don't think these need a refcounted pointer back to the
NetworkingPrivateProcessClient, since ultimately this is released when the
ShutdownIfDone is called. That happens when the map is empty, but shouldn't
happen while there are outstanding calls being made.

[mef, 2013/10/21 23:29:16]

Done. It was my attempt to use refcounting instead of explicit ShutdownWhenDone.

+  };
+  typedef IDMap<MessageCallbacks, IDMapOwnPointer> MessageCallbacksMap;
+
+  // Launches the task to start the external process.
+  void Start();

[cbentzel, 2013/10/21 21:07:16]

Nit: Move this down near StartProcessOnIOThread declaration.

[mef, 2013/10/21 23:29:16]

Done.

+
+  // UtilityProcessHostClient implementation:
+  virtual void OnProcessCrashed(int exit_code) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  // Message handlers
+  void OnApiError(MessageCallbacksID message_id,
+                  const std::string& error_code,
+                  const base::DictionaryValue& error_data);
+  void OnGetPropertiesSucceeded(MessageCallbacksID message_id,
+                                const std::string& network_guid,
+                                const base::DictionaryValue& properties);
+  void OnGetVisibleNetworksSucceeded(MessageCallbacksID message_id,
+                                     const base::ListValue& network_list);
+  void OnNetworksChangedEvent(const std::vector<std::string>& network_guids);
+  void OnNetworkListChangedEvent(const std::vector<std::string>& network_guids);
+  void OnSetPropertiesSucceeded(MessageCallbacksID message_id,
+                                const std::string& network_guid);
+  void OnStartConnectSucceeded(MessageCallbacksID message_id,
+                               const std::string& network_guid);
+  void OnStartDisconnectSucceeded(MessageCallbacksID message_id,
+                                  const std::string& network_guid);
+
+  virtual ~NetworkingPrivateProcessClient();
+
+  // Creates a new UtilityProcessHost, which launches the utility process.
+  void StartProcessOnIOThread(content::BrowserThread::ID thread_id);
+  // Deletes a UtilityProcessHost, which stops the utility process.
+  void ShutdownProcessOnIOThread();
+  // Shuts down utility process if there are no more events listeners and
+  // all calls are completed.
+  void ShutdownIfDone();
+
+  // Sends message to UtilityProcess.
+  void Send(IPC::Message* message);
+  void SendOnIOThread(IPC::Message* message);
+
+  void VerifyDestinationOnWorkerThread(
+      scoped_ptr<base::ListValue> args,
+      const BoolResultCallback& callback,
+      const CryptoErrorCallback& error_callback);
+
+  void VerifyAndEncryptDataOnWorkerThread(
+      scoped_ptr<base::ListValue> args,
+      const StringResultCallback& callback,
+      const CryptoErrorCallback& error_callback);
+
+  // Add new |MessageCallbacks| to |callbacks_map_|.
+  MessageCallbacks* AddMessageCallbacks();
+  // Removes MessageCallbacks for |message_id| from |callbacks_map_|.
+  // Shuts down utility process if there are no more events listeners and
+  // all calls are completed.
+  void RemoveMessageCallbacks(MessageCallbacksID message_id);
+
+  // Callbacks to run when message is received from UtilityProcess.
+  MessageCallbacksMap callbacks_map_;
+
+  // Browser profile, which is running API listening for events.
+  Profile* profile_;
+
+  // Handles sending messages to the external process.  Deletes itself when
+  // the external process dies.
+  base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
+
+  // Observers to Network Events.
+  ObserverList<Observer> network_events_observers_;
+
+  // Interface for Verify* methods.
+  scoped_ptr<CryptoVerify> crypto_verify_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateProcessClient);
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_PROCESS_CLIENT_H_