Initial implementation of session APIs, sans WiFi component

chrome/browser/extensions/api/gcd_private/gcd_private_api.h

 // Copyright 2014 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_GCD_PRIVATE_GCD_PRIVATE_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_GCD_PRIVATE_GCD_PRIVATE_API_H_
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/chrome_extension_function.h"
 #include "chrome/browser/local_discovery/cloud_device_list_delegate.h"
 #include "chrome/browser/local_discovery/gcd_api_flow.h"
 #include "chrome/browser/local_discovery/privet_device_lister.h"
+#include "chrome/browser/local_discovery/privetv3_session.h"
 #include "chrome/browser/local_discovery/service_discovery_shared_client.h"
 #include "chrome/common/extensions/api/gcd_private.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
 
 namespace extensions {
 
+class GcdPrivateSessionHolder;
+
 class GcdPrivateAPI : public BrowserContextKeyedAPI,
                       public EventRouter::Observer,
                       public local_discovery::PrivetDeviceLister::Delegate {
  public:
+  typedef base::Callback<void(int session_id,
+                              api::gcd_private::Status status,
+                              const std::string& code,
+                              api::gcd_private::ConfirmationType type)>
+      ConfirmationCodeCallback;
+
+  typedef base::Callback<void(api::gcd_private::Status status)>
+      SessionEstablishedCallback;
+
+  typedef base::Callback<void(api::gcd_private::Status status,
+                              const base::DictionaryValue& response)>
+      MessageResponseCallback;
+
   class GCDApiFlowFactoryForTests {
    public:
     virtual ~GCDApiFlowFactoryForTests() {}
 
     virtual scoped_ptr<local_discovery::GCDApiFlow> CreateGCDApiFlow() = 0;
   };
 
   explicit GcdPrivateAPI(content::BrowserContext* context);
   virtual ~GcdPrivateAPI();
 
   static void SetGCDApiFlowFactoryForTests(GCDApiFlowFactoryForTests* factory);
 
   // BrowserContextKeyedAPI implementation.
   static BrowserContextKeyedAPIFactory<GcdPrivateAPI>* GetFactoryInstance();
 
   bool QueryForDevices();
 
+  void EstablishSession(std::string ip_address,

[asargent_no_longer_on_chrome, 2014/07/25 20:50:10]

nit: should this be "const std::string&" ? 

[Noam Samuel, 2014/07/25 21:15:56]

Done.

+                        int port,
+                        ConfirmationCodeCallback callback);
+
+  void ConfirmCode(int session_id, SessionEstablishedCallback callback);
+
+  void SendMessage(int session_id,
+                   const std::string& api,
+                   const base::DictionaryValue& input,
+                   MessageResponseCallback callback);
+
+  void RemoveSession(int session_id);
+
  private:
   friend class BrowserContextKeyedAPIFactory<GcdPrivateAPI>;
 
   typedef std::map<std::string /* id_string */,
                    linked_ptr<api::gcd_private::GCDDevice> > GCDDeviceMap;
 
+  typedef std::map<int /* session id*/, linked_ptr<GcdPrivateSessionHolder> >
+      GCDSessionMap;
+
   // EventRouter::Observer implementation.
   virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
   virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
 
   // BrowserContextKeyedAPI implementation.
   static const char* service_name() { return "GcdPrivateAPI"; }
 
   // local_discovery::PrivetDeviceLister implementation.
   virtual void DeviceChanged(
       bool added,
       const std::string& name,
       const local_discovery::DeviceDescription& description) OVERRIDE;
   virtual void DeviceRemoved(const std::string& name) OVERRIDE;
   virtual void DeviceCacheFlushed() OVERRIDE;
 
   int num_device_listeners_;
   scoped_refptr<local_discovery::ServiceDiscoverySharedClient>
       service_discovery_client_;
   scoped_ptr<local_discovery::PrivetDeviceLister> privet_device_lister_;
   GCDDeviceMap known_devices_;
 
+  GCDSessionMap sessions_;
+  int last_session_id_;
+
   content::BrowserContext* const browser_context_;
 };
 
 class GcdPrivateGetCloudDeviceListFunction
     : public ChromeAsyncExtensionFunction,
       public local_discovery::CloudDeviceListDelegate {
  public:
   DECLARE_EXTENSION_FUNCTION("gcdPrivate.getCloudDeviceList",
                              GCDPRIVATE_GETCLOUDDEVICELIST)
 
@@ skipping 55 matching lines @@
   DECLARE_EXTENSION_FUNCTION("gcdPrivate.establishSession",
                              GCDPRIVATE_ESTABLISHSESSION)
 
   GcdPrivateEstablishSessionFunction();
 
  protected:
   virtual ~GcdPrivateEstablishSessionFunction();
 
   // AsyncExtensionFunction overrides.
   virtual bool RunAsync() OVERRIDE;
+
+ private:
+  void OnConfirmCodeCallback(
+      int session_id,
+      api::gcd_private::Status status,
+      const std::string& confirm_code,
+      api::gcd_private::ConfirmationType confirmation_type);
 };
 
 class GcdPrivateConfirmCodeFunction : public ChromeAsyncExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("gcdPrivate.confirmCode", GCDPRIVATE_CONFIRMCODE)
 
   GcdPrivateConfirmCodeFunction();
 
  protected:
   virtual ~GcdPrivateConfirmCodeFunction();
 
   // AsyncExtensionFunction overrides.
   virtual bool RunAsync() OVERRIDE;
 
  private:
+  void OnSessionEstablishedCallback(api::gcd_private::Status status);
 };
 
 class GcdPrivateSendMessageFunction : public ChromeAsyncExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("gcdPrivate.sendMessage", GCDPRIVATE_SENDMESSAGE)
 
   GcdPrivateSendMessageFunction();
 
  protected:
   virtual ~GcdPrivateSendMessageFunction();
 
   // AsyncExtensionFunction overrides.
   virtual bool RunAsync() OVERRIDE;
 
  private:
+  void OnMessageSentCallback(api::gcd_private::Status status,
+                             const base::DictionaryValue& value);
 };
 
 class GcdPrivateTerminateSessionFunction : public ChromeAsyncExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("gcdPrivate.terminateSession",
                              GCDPRIVATE_TERMINATESESSION)
 
   GcdPrivateTerminateSessionFunction();
 
  protected:
@@ skipping 79 matching lines @@
 
   // AsyncExtensionFunction overrides.
   virtual bool RunAsync() OVERRIDE;
 
  private:
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_GCD_PRIVATE_GCD_PRIVATE_API_H_