content/renderer/p2p/socket_dispatcher.h

   1 // Copyright (c) 2012 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 // P2PSocketDispatcher is a per-renderer object that dispatchers all
   6 // P2P messages received from the browser and relays all P2P messages
   7 // sent to the browser. P2PSocketClient instances register themselves
   8 // with the dispatcher using RegisterClient() and UnregisterClient().
   9 //
  10 // Relationship of classes.
  11 //
  12 //       P2PSocketHost                     P2PSocketClient
  13 //            ^                                   ^
  14 //            |                                   |
  15 //            v                  IPC              v
  16 //  P2PSocketDispatcherHost  <--------->  P2PSocketDispatcher
  17 //
  18 // P2PSocketDispatcher receives and dispatches messages on the
  19 // IO thread.
  20
  21 #ifndef CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_
  22 #define CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_
  23
  24 #include <vector>
  25
  26 #include "base/callback_forward.h"
  27 #include "base/compiler_specific.h"
  28 #include "base/id_map.h"
  29 #include "base/observer_list_threadsafe.h"
  30 #include "base/synchronization/lock.h"
  31 #include "content/common/content_export.h"
  32 #include "content/common/p2p_socket_type.h"
  33 #include "content/renderer/p2p/network_list_manager.h"
  34 #include "ipc/message_filter.h"
  35 #include "net/base/net_util.h"
  36
  37 namespace base {
  38 class SingleThreadTaskRunner;
  39 }  // namespace base
  40
  41 namespace net {
  42 class IPEndPoint;
  43 }  // namespace net
  44
  45 namespace content {
  46
  47 class NetworkListObserver;
  48 class P2PAsyncAddressResolver;
  49 class P2PSocketClientImpl;
  50 class RenderViewImpl;
  51
  52 class CONTENT_EXPORT P2PSocketDispatcher : public IPC::MessageFilter,
  53                                            public NetworkListManager {
  54  public:
  55   explicit P2PSocketDispatcher(base::SingleThreadTaskRunner* ipc_task_runner);
  56
  57   // NetworkListManager interface:
  58   void AddNetworkListObserver(
  59       NetworkListObserver* network_list_observer) override;
  60   void RemoveNetworkListObserver(
  61       NetworkListObserver* network_list_observer) override;
  62
  63   bool connected() { return connected_; }
  64
  65  protected:
  66   ~P2PSocketDispatcher() override;
  67
  68  private:
  69   friend class P2PAsyncAddressResolver;
  70   friend class P2PSocketClientImpl;
  71
  72   // Send a message asynchronously.
  73   virtual void Send(IPC::Message* message);
  74
  75   // IPC::MessageFilter override. Called on IO thread.
  76   bool OnMessageReceived(const IPC::Message& message) override;
  77   void OnFilterAdded(IPC::Sender* sender) override;
  78   void OnFilterRemoved() override;
  79   void OnChannelClosing() override;
  80   void OnChannelConnected(int32 peer_pid) override;
  81
  82   base::SingleThreadTaskRunner* task_runner();
  83
  84   // Called by P2PSocketClient.
  85   int RegisterClient(P2PSocketClientImpl* client);
  86   void UnregisterClient(int id);
  87   void SendP2PMessage(IPC::Message* msg);
  88
  89   // Called by DnsRequest.
  90   int RegisterHostAddressRequest(P2PAsyncAddressResolver* request);
  91   void UnregisterHostAddressRequest(int id);
  92
  93   // Incoming message handlers.
  94   void OnNetworkListChanged(const net::NetworkInterfaceList& networks);
  95   void OnGetHostAddressResult(int32 request_id,
  96                               const net::IPAddressList& addresses);
  97   void OnSocketCreated(int socket_id,
  98                        const net::IPEndPoint& local_address,
  99                        const net::IPEndPoint& remote_address);
 100   void OnIncomingTcpConnection(int socket_id, const net::IPEndPoint& address);
 101   void OnSendComplete(int socket_id, const P2PSendPacketMetrics& send_metrics);
 102   void OnError(int socket_id);
 103   void OnDataReceived(int socket_id, const net::IPEndPoint& address,
 104                       const std::vector<char>& data,
 105                       const base::TimeTicks& timestamp);
 106
 107   P2PSocketClientImpl* GetClient(int socket_id);
 108
 109   scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
 110   IDMap<P2PSocketClientImpl> clients_;
 111
 112   IDMap<P2PAsyncAddressResolver> host_address_requests_;
 113
 114   bool network_notifications_started_;
 115   scoped_refptr<base::ObserverListThreadSafe<NetworkListObserver>>
 116       network_list_observers_;
 117
 118   IPC::Sender* sender_;
 119
 120   // To indicate whether IPC could be invoked on this dispatcher.
 121   bool connected_ = false;
 122
 123   DISALLOW_COPY_AND_ASSIGN(P2PSocketDispatcher);
 124 };
 125
 126 }  // namespace content
 127
 128 #endif  // CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_