Adding the Copresence RpcHandler and HttpPost helper.

components/copresence/rpc/rpc_handler.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 COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_
 #define COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_
 
+#include <google/protobuf/repeated_field.h>
+
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
-#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/public/copresence_client_delegate.h"
+#include "components/copresence/public/whispernet_client.h"
+#include "components/copresence/rpc/http_post.h"
+#include "components/copresence/timed_map.h"
 
 namespace copresence {
 
+class DirectiveHandler;
 class ReportRequest;
-class WhispernetClient;
+class RequestHeader;
+class SubscribedMessage;
 
 // This class currently handles all communication with the copresence server.
-// NOTE: This class is a stub.
-class RpcHandler {
+class RpcHandler : public base::SupportsWeakPtr<RpcHandler> {
  public:
   // A callback to indicate whether handler initialization succeeded.
   typedef base::Callback<void(bool)> SuccessCallback;
 
-  // Constructor. May call the server to register a device,
-  // so completion status is indicated by the SuccessCallback.
-  RpcHandler(CopresenceClientDelegate* delegate,
-             SuccessCallback init_done_callback);
+  // Report rpc name to send to Apiary.
+  static const char kReportRequestRpcName[];
+
+  // Constructor. |delegate| is owned by the caller,
+  // and must be valid as long as the RpcHandler exists.
+  explicit RpcHandler(CopresenceClientDelegate* delegate);
 
   virtual ~RpcHandler();
 
+  // Clients must call this and wait for |init_done_callback|
+  // to be called before invoking any other methods.
+  void Initialize(const SuccessCallback& init_done_callback);
+
   // Send a report request
-  void SendReportRequest(scoped_ptr<copresence::ReportRequest> request);
-  void SendReportRequest(scoped_ptr<copresence::ReportRequest> request,
+  void SendReportRequest(scoped_ptr<ReportRequest> request);
+  void SendReportRequest(scoped_ptr<ReportRequest> request,
                          const std::string& app_id,
                          const StatusCallback& callback);
 
   // Report a set of tokens to the server for a given medium.
-  void ReportTokens(copresence::TokenMedium medium,
-                    const std::vector<std::string>& tokens);
+  void ReportTokens(TokenMedium medium, const std::vector<std::string>& tokens);
 
-  // Create the directive handler and connect it to the whispernet client.
-  void ConnectToWhispernet(WhispernetClient* whispernet_client);
+  // Create the directive handler and connect it to
+  // the whispernet client specified by the delegate.
+  void ConnectToWhispernet();
 
   // Disconnect the directive handler from the whispernet client.
   void DisconnectFromWhispernet();
 
  private:
+  // Callback to allow tests to stub out HTTP POST behavior.
+  // Arguments:
+  // URLRequestContextGetter: Context for the HTTP POST request.
+  // string: Name of the rpc to invoke. URL format: server.google.com/rpc_name
+  // MessageLite: Contents of POST request to be sent. This needs to be
+  //     a (scoped) pointer to ease handling of the abstract MessageLite class.
+  // ResponseCallback: Receives the response to the request.
+  typedef base::Callback<void(net::URLRequestContextGetter*,
+                              const std::string&,
+                              scoped_ptr<google::protobuf::MessageLite>,
+                              const HttpPost::ResponseCallback&)> PostCallback;
+
+  friend class RpcHandlerTest;
+
+  void RegisterResponseHandler(const SuccessCallback& init_done_callback,
+                               int http_status_code,
+                               const std::string& response_data,
+                               HttpPost* completed_post);
+  void ReportResponseHandler(const StatusCallback& status_callback,
+                             int http_status_code,
+                             const std::string& response_data,
+                             HttpPost* completed_post);
+
+  void DispatchMessages(
+      const google::protobuf::RepeatedPtrField<SubscribedMessage>&
+      subscribed_messages);
+
+  RequestHeader* CreateRequestHeader(const std::string& client_name) const;
+
+  template <class T>
+  void SendServerRequest(const std::string& rpc_name,
+                         const std::string& app_id,
+                         scoped_ptr<T> request,
+                         const HttpPost::ResponseCallback& response_handler);
+
+  // Wrapper for the http post constructor. This is the default way
+  // to contact the server, but it can be overridden for testing.
+  void SendHttpPost(net::URLRequestContextGetter* url_context_getter,
+                    const std::string& rpc_name,
+                    scoped_ptr<google::protobuf::MessageLite> request_proto,
+                    const HttpPost::ResponseCallback& callback);
+
+  // This method receives the request to encode a token and forwards it to
+  // whispernet, setting the samples return callback to samples_callback.
+  void AudioDirectiveListToWhispernetConnector(
+      const std::string& token,
+      const WhispernetClient::SamplesCallback& samples_callback);
+
+  CopresenceClientDelegate* delegate_;  // Belongs to the caller.
+  TimedMap<std::string, bool> invalid_audio_token_cache_;
+  PostCallback server_post_callback_;
+
+  std::string device_id_;
+  scoped_ptr<DirectiveHandler> directive_handler_;
+  std::set<HttpPost*> pending_posts_;
+
   DISALLOW_COPY_AND_ASSIGN(RpcHandler);
 };
 
 }  // namespace copresence
 
 #endif  // COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_