components/copresence/rpc/rpc_handler.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_
   6 #define COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_
   7
   8 #include <set>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/callback.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "components/copresence/proto/enums.pb.h"
  15 #include "components/copresence/public/copresence_delegate.h"
  16 #include "components/copresence/public/whispernet_client.h"
  17 #include "components/copresence/rpc/http_post.h"
  18 #include "components/copresence/timed_map.h"
  19
  20 namespace copresence {
  21
  22 class DirectiveHandler;
  23 class ReportRequest;
  24 class RequestHeader;
  25 class SubscribedMessage;
  26
  27 // This class currently handles all communication with the copresence server.
  28 class RpcHandler {
  29  public:
  30   // A callback to indicate whether handler initialization succeeded.
  31   typedef base::Callback<void(bool)> SuccessCallback;
  32
  33   // Report rpc name to send to Apiary.
  34   static const char kReportRequestRpcName[];
  35
  36   // Constructor. |delegate| is owned by the caller,
  37   // and must be valid as long as the RpcHandler exists.
  38   explicit RpcHandler(CopresenceDelegate* delegate);
  39
  40   virtual ~RpcHandler();
  41
  42   // Clients must call this and wait for |init_done_callback|
  43   // to be called before invoking any other methods.
  44   void Initialize(const SuccessCallback& init_done_callback);
  45
  46   // Send a report request.
  47   void SendReportRequest(scoped_ptr<ReportRequest> request);
  48   void SendReportRequest(scoped_ptr<ReportRequest> request,
  49                          const std::string& app_id,
  50                          const StatusCallback& callback);
  51
  52   // Report a set of tokens to the server for a given medium.
  53   void ReportTokens(const std::vector<AudioToken>& tokens);
  54
  55   // Create the directive handler and connect it to
  56   // the whispernet client specified by the delegate.
  57   void ConnectToWhispernet();
  58
  59  private:
  60   // An HttpPost::ResponseCallback prepended with an HttpPost object
  61   // that needs to be deleted.
  62   typedef base::Callback<void(HttpPost*, int, const std::string&)>
  63       PostCleanupCallback;
  64
  65   // Callback to allow tests to stub out HTTP POST behavior.
  66   // Arguments:
  67   // URLRequestContextGetter: Context for the HTTP POST request.
  68   // string: Name of the rpc to invoke. URL format: server.google.com/rpc_name
  69   // MessageLite: Contents of POST request to be sent. This needs to be
  70   //     a (scoped) pointer to ease handling of the abstract MessageLite class.
  71   // ResponseCallback: Receives the response to the request.
  72   typedef base::Callback<void(net::URLRequestContextGetter*,
  73                               const std::string&,
  74                               scoped_ptr<google::protobuf::MessageLite>,
  75                               const PostCleanupCallback&)> PostCallback;
  76
  77   friend class RpcHandlerTest;
  78
  79   void RegisterResponseHandler(const SuccessCallback& init_done_callback,
  80                                HttpPost* completed_post,
  81                                int http_status_code,
  82                                const std::string& response_data);
  83   void ReportResponseHandler(const StatusCallback& status_callback,
  84                              HttpPost* completed_post,
  85                              int http_status_code,
  86                              const std::string& response_data);
  87
  88   // If the request has any unpublish or unsubscribe operations, it removes
  89   // them from our directive handlers.
  90   void ProcessRemovedOperations(const ReportRequest& request);
  91
  92   // Add all currently playing tokens to the update signals in this report
  93   // request. This ensures that the server doesn't keep issueing new tokens to
  94   // us when we're already playing valid tokens.
  95   void AddPlayingTokens(ReportRequest* request);
  96
  97   void DispatchMessages(
  98       const google::protobuf::RepeatedPtrField<SubscribedMessage>&
  99       subscribed_messages);
 100
 101   RequestHeader* CreateRequestHeader(const std::string& client_name) const;
 102
 103   template <class T>
 104   void SendServerRequest(const std::string& rpc_name,
 105                          const std::string& app_id,
 106                          scoped_ptr<T> request,
 107                          const PostCleanupCallback& response_handler);
 108
 109   // Wrapper for the http post constructor. This is the default way
 110   // to contact the server, but it can be overridden for testing.
 111   void SendHttpPost(net::URLRequestContextGetter* url_context_getter,
 112                     const std::string& rpc_name,
 113                     scoped_ptr<google::protobuf::MessageLite> request_proto,
 114                     const PostCleanupCallback& callback);
 115
 116   // This method receives the request to encode a token and forwards it to
 117   // whispernet, setting the samples return callback to samples_callback.
 118   void AudioDirectiveListToWhispernetConnector(
 119       const std::string& token,
 120       bool audible,
 121       const WhispernetClient::SamplesCallback& samples_callback);
 122
 123   CopresenceDelegate* delegate_;  // Belongs to the caller.
 124   TimedMap<std::string, bool> invalid_audio_token_cache_;
 125   PostCallback server_post_callback_;
 126
 127   std::string device_id_;
 128   scoped_ptr<DirectiveHandler> directive_handler_;
 129   std::set<HttpPost*> pending_posts_;
 130
 131   DISALLOW_COPY_AND_ASSIGN(RpcHandler);
 132 };
 133
 134 }  // namespace copresence
 135
 136 #endif  // COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_