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,
+                        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);
+
  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> >

[Vitaly Buka (NO REVIEWS), 2014/07/24 20:50:18]

You don't need map, ScopedVector<> should be enough here.
it's not likely to have large number of open sessions

[Noam Samuel, 2014/07/24 21:11:22]

Not sure what the benefit of using a vector over a map is here.

[Noam Samuel, 2014/07/24 21:55:45]

Replaced std::vector< linked_ptr< >> with ScopedVector.

+      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 GcdPrivateRequest : public local_discovery::PrivetV3Session::Request {

[Vitaly Buka (NO REVIEWS), 2014/07/24 20:50:18]

this should be defined in cc file

[Noam Samuel, 2014/07/24 21:55:45]

Done.

+ public:
+  GcdPrivateRequest(const std::string& api,
+                    const base::DictionaryValue& input,
+                    const GcdPrivateAPI::MessageResponseCallback& callback,
+                    GcdPrivateSessionHolder* session_holder);
+  virtual ~GcdPrivateRequest();
+
+  // local_discovery::PrivetV3Session::Request implementation.
+  virtual std::string GetName() OVERRIDE;
+  virtual const base::DictionaryValue& GetInput() OVERRIDE;
+  virtual void OnError(
+      local_discovery::PrivetURLFetcher::ErrorType error) OVERRIDE;
+  virtual void OnParsedJson(const base::DictionaryValue& value,
+                            bool has_error) OVERRIDE;
+
+ private:
+  std::string api_;
+  scoped_ptr<base::DictionaryValue> input_;
+  GcdPrivateAPI::MessageResponseCallback callback_;
+  GcdPrivateSessionHolder* session_holder_;
+};
+
+class GcdPrivateSessionHolder

[Vitaly Buka (NO REVIEWS), 2014/07/24 20:50:19]

GcdPrivateSessionHolder also could be hidden in CC file

[Noam Samuel, 2014/07/24 21:55:45]

Done.

+    : public local_discovery::PrivetV3Session::Delegate {
+ public:
+  typedef base::Callback<void(api::gcd_private::Status status,
+                              const std::string& code,
+                              api::gcd_private::ConfirmationType type)>
+      ConfirmationCodeCallback;
+
+  GcdPrivateSessionHolder(const std::string& ip_address,
+                          int port,
+                          net::URLRequestContextGetter* request_context);
+  virtual ~GcdPrivateSessionHolder();
+
+  void Start(const ConfirmationCodeCallback& callback);
+
+  void ConfirmCode(const GcdPrivateAPI::SessionEstablishedCallback& callback);
+
+  void SendMessage(const std::string& api,
+                   const base::DictionaryValue& input,
+                   GcdPrivateAPI::MessageResponseCallback callback);
+
+  void DeleteRequest(GcdPrivateRequest* request);
+
+ private:
+  // local_discovery::PrivetV3Session::Delegate implementation.
+  virtual void OnSetupConfirmationNeeded(
+      const std::string& confirmation_code) OVERRIDE;
+  virtual void OnSessionEstablished() OVERRIDE;
+  virtual void OnCannotEstablishSession() OVERRIDE;
+
+  scoped_ptr<local_discovery::PrivetHTTPClient> http_client_;
+  scoped_ptr<local_discovery::PrivetV3Session> privet_session_;
+  typedef std::vector<linked_ptr<GcdPrivateRequest> > RequestVector;
+  RequestVector requests_;
+
+  ConfirmationCodeCallback confirm_callback_;
+  GcdPrivateAPI::SessionEstablishedCallback session_established_callback_;
+};
+
 class GcdPrivateGetCloudDeviceListFunction
     : public ChromeAsyncExtensionFunction,
       public local_discovery::CloudDeviceListDelegate {
  public:
   DECLARE_EXTENSION_FUNCTION("gcdPrivate.getCloudDeviceList",
                              GCDPRIVATE_GETCLOUDDEVICELIST)
 
   GcdPrivateGetCloudDeviceListFunction();
 
  protected:
@@ skipping 52 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_