Expose the p2p client in content/public

content/renderer/p2p/socket_dispatcher.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/p2p/socket_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/child/child_process.h"
 #include "content/common/p2p_messages.h"
 #include "content/renderer/p2p/host_address_request.h"
 #include "content/renderer/p2p/network_list_observer.h"
 #include "content/renderer/p2p/socket_client.h"
 #include "content/renderer/render_view_impl.h"
 
 namespace content {
 
 P2PSocketDispatcher::P2PSocketDispatcher(
     base::MessageLoopProxy* ipc_message_loop)
     : message_loop_(ipc_message_loop),
       network_notifications_started_(false),
       network_list_observers_(
           new ObserverListThreadSafe<NetworkListObserver>()),
       channel_(NULL) {
 }
 
 P2PSocketDispatcher::~P2PSocketDispatcher() {
   network_list_observers_->AssertEmpty();
-  for (IDMap<P2PSocketClient>::iterator i(&clients_); !i.IsAtEnd();
+  for (IDMap<P2PSocketClientImpl>::iterator i(&clients_); !i.IsAtEnd();
        i.Advance()) {
     i.GetCurrentValue()->Detach();
   }
 }
 
 void P2PSocketDispatcher::AddNetworkListObserver(
     NetworkListObserver* network_list_observer) {
   network_list_observers_->AddObserver(network_list_observer);
   network_notifications_started_ = true;
   SendP2PMessage(new P2PHostMsg_StartNetworkNotifications());
@@ skipping 40 matching lines @@
 }
 
 void P2PSocketDispatcher::OnChannelClosing() {
   channel_ = NULL;
 }
 
 base::MessageLoopProxy* P2PSocketDispatcher::message_loop() {
   return message_loop_.get();
 }
 
-int P2PSocketDispatcher::RegisterClient(P2PSocketClient* client) {
+int P2PSocketDispatcher::RegisterClient(P2PSocketClientImpl* client) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   return clients_.Add(client);
 }
 
 void P2PSocketDispatcher::UnregisterClient(int id) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   clients_.Remove(id);
 }
 
 void P2PSocketDispatcher::SendP2PMessage(IPC::Message* msg) {
@@ skipping 30 matching lines @@
   if (!request) {
     VLOG(1) << "Received P2P message for socket that doesn't exist.";
     return;
   }
 
   request->OnResponse(address);
 }
 
 void P2PSocketDispatcher::OnSocketCreated(
     int socket_id, const net::IPEndPoint& address) {
-  P2PSocketClient* client = GetClient(socket_id);
+  P2PSocketClientImpl* client = GetClient(socket_id);
   if (client) {
     client->OnSocketCreated(address);
   }
 }
 
 void P2PSocketDispatcher::OnIncomingTcpConnection(
     int socket_id, const net::IPEndPoint& address) {
-  P2PSocketClient* client = GetClient(socket_id);
+  P2PSocketClientImpl* client = GetClient(socket_id);
   if (client) {
     client->OnIncomingTcpConnection(address);
   }
 }
 
 void P2PSocketDispatcher::OnSendComplete(int socket_id) {
-  P2PSocketClient* client = GetClient(socket_id);
+  P2PSocketClientImpl* client = GetClient(socket_id);
   if (client) {
     client->OnSendComplete();
   }
 }
 
 void P2PSocketDispatcher::OnError(int socket_id) {
-  P2PSocketClient* client = GetClient(socket_id);
+  P2PSocketClientImpl* client = GetClient(socket_id);
   if (client) {
     client->OnError();
   }
 }
 
 void P2PSocketDispatcher::OnDataReceived(
     int socket_id, const net::IPEndPoint& address,
     const std::vector<char>& data) {
-  P2PSocketClient* client = GetClient(socket_id);
+  P2PSocketClientImpl* client = GetClient(socket_id);
   if (client) {
     client->OnDataReceived(address, data);
   }
 }
 
-P2PSocketClient* P2PSocketDispatcher::GetClient(int socket_id) {
-  P2PSocketClient* client = clients_.Lookup(socket_id);
+P2PSocketClientImpl* P2PSocketDispatcher::GetClient(int socket_id) {
+  P2PSocketClientImpl* client = clients_.Lookup(socket_id);
   if (client == NULL) {
     // This may happen if the socket was closed, but the browser side
     // hasn't processed the close message by the time it sends the
     // message to the renderer.
     VLOG(1) << "Received P2P message for socket that doesn't exist.";
     return NULL;
   }
 
   return client;
 }
 
 }  // namespace content