Home | History | Annotate | Download | only in p2p 
      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/public/common/p2p_socket_type.h"
     33 #include "ipc/ipc_channel_proxy.h"
     34 #include "net/base/net_util.h"
     35 
     36 namespace base {
     37 class MessageLoopProxy;
     38 }  // namespace base
     39 
     40 namespace net {
     41 class IPEndPoint;
     42 }  // namespace net
     43 
     44 namespace content {
     45 
     46 class NetworkListObserver;
     47 class RenderViewImpl;
     48 class P2PHostAddressRequest;
     49 class P2PSocketClientImpl;
     50 
     51 class CONTENT_EXPORT P2PSocketDispatcher
     52     : public IPC::ChannelProxy::MessageFilter {
     53  public:
     54   P2PSocketDispatcher(base::MessageLoopProxy* ipc_message_loop);
     55 
     56   // Add a new network list observer. Each observer is called
     57   // immidiately after it is registered and then later whenever
     58   // network configuration changes. Can be called on any thread. The
     59   // observer is always called on the thread it was added.
     60   void AddNetworkListObserver(NetworkListObserver* network_list_observer);
     61 
     62   // Removes network list observer. Must be called on the thread on
     63   // which the observer was added.
     64   void RemoveNetworkListObserver(NetworkListObserver* network_list_observer);
     65 
     66  protected:
     67   virtual ~P2PSocketDispatcher();
     68 
     69  private:
     70   friend class P2PHostAddressRequest;
     71   friend class P2PSocketClientImpl;
     72 
     73   // Send a message asynchronously.
     74   virtual void Send(IPC::Message* message);
     75 
     76   // IPC::ChannelProxy::MessageFilter override. Called on IO thread.
     77   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
     78   virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE;
     79   virtual void OnFilterRemoved() OVERRIDE;
     80   virtual void OnChannelClosing() OVERRIDE;
     81 
     82   // Returns the IO message loop.
     83   base::MessageLoopProxy* message_loop();
     84 
     85   // Called by P2PSocketClient.
     86   int RegisterClient(P2PSocketClientImpl* client);
     87   void UnregisterClient(int id);
     88   void SendP2PMessage(IPC::Message* msg);
     89 
     90   // Called by DnsRequest.
     91   int RegisterHostAddressRequest(P2PHostAddressRequest* request);
     92   void UnregisterHostAddressRequest(int id);
     93 
     94   // Incoming message handlers.
     95   void OnNetworkListChanged(const net::NetworkInterfaceList& networks);
     96   void OnGetHostAddressResult(int32 request_id,
     97                               const net::IPAddressNumber& address);
     98   void OnSocketCreated(int socket_id, const net::IPEndPoint& address);
     99   void OnIncomingTcpConnection(int socket_id, const net::IPEndPoint& address);
    100   void OnSendComplete(int socket_id);
    101   void OnError(int socket_id);
    102   void OnDataReceived(int socket_id, const net::IPEndPoint& address,
    103                       const std::vector<char>& data,
    104                       const base::TimeTicks& timestamp);
    105 
    106   P2PSocketClientImpl* GetClient(int socket_id);
    107 
    108   scoped_refptr<base::MessageLoopProxy> message_loop_;
    109   IDMap<P2PSocketClientImpl> clients_;
    110 
    111   IDMap<P2PHostAddressRequest> host_address_requests_;
    112 
    113   bool network_notifications_started_;
    114   scoped_refptr<ObserverListThreadSafe<NetworkListObserver> >
    115       network_list_observers_;
    116 
    117   IPC::Channel* channel_;
    118 
    119   DISALLOW_COPY_AND_ASSIGN(P2PSocketDispatcher);
    120 };
    121 
    122 }  // namespace content
    123 
    124 #endif  // CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_
    125