extensions/browser/api/sockets_udp/udp_socket_event_dispatcher.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_SOCKETS_UDP_UDP_SOCKET_EVENT_DISPATCHER_H_
   6 #define EXTENSIONS_BROWSER_API_SOCKETS_UDP_UDP_SOCKET_EVENT_DISPATCHER_H_
   7
   8 #include "extensions/browser/api/api_resource_manager.h"
   9 #include "extensions/browser/api/sockets_udp/sockets_udp_api.h"
  10
  11 namespace content {
  12 class BrowserContext;
  13 }
  14
  15 namespace extensions {
  16 struct Event;
  17 class ResumableUDPSocket;
  18 }
  19
  20 namespace extensions {
  21 namespace core_api {
  22
  23 // Dispatch events related to "sockets.udp" sockets from callback on native
  24 // socket instances. There is one instance per profile.
  25 class UDPSocketEventDispatcher
  26     : public BrowserContextKeyedAPI,
  27       public base::SupportsWeakPtr<UDPSocketEventDispatcher> {
  28  public:
  29   explicit UDPSocketEventDispatcher(content::BrowserContext* context);
  30   virtual ~UDPSocketEventDispatcher();
  31
  32   // Socket is active, start receving from it.
  33   void OnSocketBind(const std::string& extension_id, int socket_id);
  34
  35   // Socket is active again, start receiving data from it.
  36   void OnSocketResume(const std::string& extension_id, int socket_id);
  37
  38   // BrowserContextKeyedAPI implementation.
  39   static BrowserContextKeyedAPIFactory<UDPSocketEventDispatcher>*
  40       GetFactoryInstance();
  41
  42   // Convenience method to get the SocketEventDispatcher for a profile.
  43   static UDPSocketEventDispatcher* Get(content::BrowserContext* context);
  44
  45  private:
  46   typedef ApiResourceManager<ResumableUDPSocket>::ApiResourceData SocketData;
  47   friend class BrowserContextKeyedAPIFactory<UDPSocketEventDispatcher>;
  48   // BrowserContextKeyedAPI implementation.
  49   static const char* service_name() { return "UDPSocketEventDispatcher"; }
  50   static const bool kServiceHasOwnInstanceInIncognito = true;
  51   static const bool kServiceIsNULLWhileTesting = true;
  52
  53   // base::Bind supports methods with up to 6 parameters. ReceiveParams is used
  54   // as a workaround that limitation for invoking StartReceive.
  55   struct ReceiveParams {
  56     ReceiveParams();
  57     ~ReceiveParams();
  58
  59     content::BrowserThread::ID thread_id;
  60     void* browser_context_id;
  61     std::string extension_id;
  62     scoped_refptr<SocketData> sockets;
  63     int socket_id;
  64   };
  65
  66   // Start a receive and register a callback.
  67   static void StartReceive(const ReceiveParams& params);
  68
  69   // Called when socket receive data.
  70   static void ReceiveCallback(const ReceiveParams& params,
  71                               int bytes_read,
  72                               scoped_refptr<net::IOBuffer> io_buffer,
  73                               const std::string& address,
  74                               int port);
  75
  76   // Post an extension event from IO to UI thread
  77   static void PostEvent(const ReceiveParams& params, scoped_ptr<Event> event);
  78
  79   // Dispatch an extension event on to EventRouter instance on UI thread.
  80   static void DispatchEvent(void* browser_context_id,
  81                             const std::string& extension_id,
  82                             scoped_ptr<Event> event);
  83
  84   // Usually IO thread (except for unit testing).
  85   content::BrowserThread::ID thread_id_;
  86   content::BrowserContext* const browser_context_;
  87   scoped_refptr<SocketData> sockets_;
  88 };
  89
  90 }  // namespace core_api
  91 }  // namespace extensions
  92
  93 #endif  // EXTENSIONS_BROWSER_API_SOCKETS_UDP_UDP_SOCKET_EVENT_DISPATCHER_H_