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