extensions/browser/api/cast_channel/cast_channel_api.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 EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_CHANNEL_API_H_
   6 #define EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_CHANNEL_API_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/threading/thread_checker.h"
  14 #include "extensions/browser/api/api_resource_manager.h"
  15 #include "extensions/browser/api/async_api_function.h"
  16 #include "extensions/browser/api/cast_channel/cast_socket.h"
  17 #include "extensions/browser/browser_context_keyed_api_factory.h"
  18 #include "extensions/common/api/cast_channel.h"
  19
  20 class CastChannelAPITest;
  21
  22 namespace content {
  23 class BrowserContext;
  24 }
  25
  26 namespace net {
  27 class IPEndPoint;
  28 }
  29
  30 namespace extensions {
  31
  32 struct Event;
  33
  34 namespace api {
  35 namespace cast_channel {
  36 class Logger;
  37 }  // namespace cast_channel
  38 }  // namespace api
  39
  40 namespace cast_channel = api::cast_channel;
  41
  42 class CastChannelAPI : public BrowserContextKeyedAPI,
  43                        public base::SupportsWeakPtr<CastChannelAPI> {
  44  public:
  45   explicit CastChannelAPI(content::BrowserContext* context);
  46
  47   static CastChannelAPI* Get(content::BrowserContext* context);
  48
  49   // BrowserContextKeyedAPI implementation.
  50   static BrowserContextKeyedAPIFactory<CastChannelAPI>* GetFactoryInstance();
  51
  52   // Returns a pointer to the Logger member variable.
  53   // TODO(imcheng): Consider whether it is possible for this class to own the
  54   // CastSockets and make this class the sole owner of Logger.
  55   // Alternatively,
  56   // consider making Logger not ref-counted by passing a weak
  57   // reference of Logger to the CastSockets instead.
  58   scoped_refptr<cast_channel::Logger> GetLogger();
  59
  60   // Sets the CastSocket instance to be used for testing.
  61   void SetSocketForTest(scoped_ptr<cast_channel::CastSocket> socket_for_test);
  62
  63   // Returns a test CastSocket instance, if it is defined.
  64   // Otherwise returns a scoped_ptr with a nullptr value.
  65   scoped_ptr<cast_channel::CastSocket> GetSocketForTest();
  66
  67   // Returns the API browser context.
  68   content::BrowserContext* GetBrowserContext() const;
  69
  70   // Sets injected ping timeout timer for testing.
  71   void SetPingTimeoutTimerForTest(scoped_ptr<base::Timer> timer);
  72
  73   // Gets the injected ping timeout timer, if set.
  74   // Returns a null scoped ptr if there is no injected timer.
  75   scoped_ptr<base::Timer> GetInjectedTimeoutTimerForTest();
  76
  77   // Sends an event to the extension's EventRouter, if it exists.
  78   void SendEvent(const std::string& extension_id, scoped_ptr<Event> event);
  79
  80  private:
  81   friend class BrowserContextKeyedAPIFactory<CastChannelAPI>;
  82   friend class ::CastChannelAPITest;
  83   friend class CastTransportDelegate;
  84
  85   ~CastChannelAPI() override;
  86
  87   // BrowserContextKeyedAPI implementation.
  88   static const char* service_name() { return "CastChannelAPI"; }
  89
  90   content::BrowserContext* const browser_context_;
  91   scoped_refptr<cast_channel::Logger> logger_;
  92   scoped_ptr<cast_channel::CastSocket> socket_for_test_;
  93   scoped_ptr<base::Timer> injected_timeout_timer_;
  94
  95   DISALLOW_COPY_AND_ASSIGN(CastChannelAPI);
  96 };
  97
  98 class CastChannelAsyncApiFunction : public AsyncApiFunction {
  99  public:
 100   CastChannelAsyncApiFunction();
 101
 102  protected:
 103   typedef ApiResourceManager<cast_channel::CastSocket>::ApiResourceData
 104       SocketData;
 105
 106   ~CastChannelAsyncApiFunction() override;
 107
 108   // AsyncApiFunction:
 109   bool PrePrepare() override;
 110   bool Respond() override;
 111
 112   // Returns the socket corresponding to |channel_id| if one exists.  Otherwise,
 113   // sets the function result with CHANNEL_ERROR_INVALID_CHANNEL_ID, completes
 114   // the function, and returns null.
 115   cast_channel::CastSocket* GetSocketOrCompleteWithError(int channel_id);
 116
 117   // Adds |socket| to |manager_| and returns the new channel_id.  |manager_|
 118   // assumes ownership of |socket|.
 119   int AddSocket(cast_channel::CastSocket* socket);
 120
 121   // Removes the CastSocket corresponding to |channel_id| from the resource
 122   // manager.
 123   void RemoveSocket(int channel_id);
 124
 125   // Sets the function result to a ChannelInfo obtained from the state of
 126   // |socket|.
 127   void SetResultFromSocket(const cast_channel::CastSocket& socket);
 128
 129   // Sets the function result to a ChannelInfo populated with |channel_id| and
 130   // |error|.
 131   void SetResultFromError(int channel_id, cast_channel::ChannelError error);
 132
 133   // Returns the socket corresponding to |channel_id| if one exists, or null
 134   // otherwise.
 135   cast_channel::CastSocket* GetSocket(int channel_id) const;
 136
 137  private:
 138   // Sets the function result from |channel_info|.
 139   void SetResultFromChannelInfo(const cast_channel::ChannelInfo& channel_info);
 140
 141   // The collection of CastSocket API resources.
 142   scoped_refptr<SocketData> sockets_;
 143 };
 144
 145 class CastChannelOpenFunction : public CastChannelAsyncApiFunction {
 146  public:
 147   CastChannelOpenFunction();
 148
 149  protected:
 150   ~CastChannelOpenFunction() override;
 151
 152   // AsyncApiFunction:
 153   bool PrePrepare() override;
 154   bool Prepare() override;
 155   void AsyncWorkStart() override;
 156
 157  private:
 158   DECLARE_EXTENSION_FUNCTION("cast.channel.open", CAST_CHANNEL_OPEN)
 159
 160   // Defines a callback used to send events to the extension's
 161   // EventRouter.
 162   //     Parameter #0 is the extension's ID.
 163   //     Parameter #1 is a scoped pointer to the event payload.
 164   using EventDispatchCallback =
 165       base::Callback<void(const std::string&, scoped_ptr<Event>)>;
 166
 167   // Receives incoming messages and errors and provides additional API and
 168   // origin socket context.
 169   class CastMessageHandler : public cast_channel::CastTransport::Delegate {
 170    public:
 171     CastMessageHandler(const EventDispatchCallback& ui_dispatch_cb,
 172                        cast_channel::CastSocket* socket,
 173                        scoped_refptr<api::cast_channel::Logger> logger);
 174     ~CastMessageHandler() override;
 175
 176     // CastTransport::Delegate implementation.
 177     void OnError(cast_channel::ChannelError error_state) override;
 178     void OnMessage(const cast_channel::CastMessage& message) override;
 179     void Start() override;
 180
 181    private:
 182     // Callback for sending events to the extension.
 183     // Should be bound to a weak pointer, to prevent any use-after-free
 184     // conditions.
 185     EventDispatchCallback const ui_dispatch_cb_;
 186     cast_channel::CastSocket* const socket_;
 187     // Logger object for reporting error details.
 188     scoped_refptr<api::cast_channel::Logger> logger_;
 189
 190     DISALLOW_COPY_AND_ASSIGN(CastMessageHandler);
 191   };
 192
 193   // Validates that |connect_info| represents a valid IP end point and returns a
 194   // new IPEndPoint if so.  Otherwise returns nullptr.
 195   static net::IPEndPoint* ParseConnectInfo(
 196       const cast_channel::ConnectInfo& connect_info);
 197
 198   void OnOpen(cast_channel::ChannelError result);
 199
 200   scoped_ptr<cast_channel::Open::Params> params_;
 201   // The id of the newly opened socket.
 202   int new_channel_id_;
 203   CastChannelAPI* api_;
 204   scoped_ptr<net::IPEndPoint> ip_endpoint_;
 205   cast_channel::ChannelAuthType channel_auth_;
 206   base::TimeDelta liveness_timeout_;
 207   base::TimeDelta ping_interval_;
 208
 209   FRIEND_TEST_ALL_PREFIXES(CastChannelOpenFunctionTest, TestParseConnectInfo);
 210   DISALLOW_COPY_AND_ASSIGN(CastChannelOpenFunction);
 211 };
 212
 213 class CastChannelSendFunction : public CastChannelAsyncApiFunction {
 214  public:
 215   CastChannelSendFunction();
 216
 217  protected:
 218   ~CastChannelSendFunction() override;
 219
 220   // AsyncApiFunction:
 221   bool Prepare() override;
 222   void AsyncWorkStart() override;
 223
 224  private:
 225   DECLARE_EXTENSION_FUNCTION("cast.channel.send", CAST_CHANNEL_SEND)
 226
 227   void OnSend(int result);
 228
 229   scoped_ptr<cast_channel::Send::Params> params_;
 230
 231   DISALLOW_COPY_AND_ASSIGN(CastChannelSendFunction);
 232 };
 233
 234 class CastChannelCloseFunction : public CastChannelAsyncApiFunction {
 235  public:
 236   CastChannelCloseFunction();
 237
 238  protected:
 239   ~CastChannelCloseFunction() override;
 240
 241   // AsyncApiFunction:
 242   bool Prepare() override;
 243   void AsyncWorkStart() override;
 244
 245  private:
 246   DECLARE_EXTENSION_FUNCTION("cast.channel.close", CAST_CHANNEL_CLOSE)
 247
 248   void OnClose(int result);
 249
 250   scoped_ptr<cast_channel::Close::Params> params_;
 251
 252   DISALLOW_COPY_AND_ASSIGN(CastChannelCloseFunction);
 253 };
 254
 255 class CastChannelGetLogsFunction : public CastChannelAsyncApiFunction {
 256  public:
 257   CastChannelGetLogsFunction();
 258
 259  protected:
 260   ~CastChannelGetLogsFunction() override;
 261
 262   // AsyncApiFunction:
 263   bool PrePrepare() override;
 264   bool Prepare() override;
 265   void AsyncWorkStart() override;
 266
 267  private:
 268   DECLARE_EXTENSION_FUNCTION("cast.channel.getLogs", CAST_CHANNEL_GETLOGS)
 269
 270   CastChannelAPI* api_;
 271
 272   DISALLOW_COPY_AND_ASSIGN(CastChannelGetLogsFunction);
 273 };
 274
 275 class CastChannelSetAuthorityKeysFunction : public CastChannelAsyncApiFunction {
 276  public:
 277   CastChannelSetAuthorityKeysFunction();
 278
 279  protected:
 280   ~CastChannelSetAuthorityKeysFunction() override;
 281
 282   // AsyncApiFunction:
 283   bool Prepare() override;
 284   void AsyncWorkStart() override;
 285
 286  private:
 287   DECLARE_EXTENSION_FUNCTION("cast.channel.setAuthorityKeys",
 288                              CAST_CHANNEL_SETAUTHORITYKEYS)
 289
 290   scoped_ptr<cast_channel::SetAuthorityKeys::Params> params_;
 291
 292   DISALLOW_COPY_AND_ASSIGN(CastChannelSetAuthorityKeysFunction);
 293 };
 294
 295 }  // namespace extensions
 296
 297 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_CHANNEL_API_H_