Cleanup ConnectionToHost of non-P2P-API code.

BUG=74951
TEST=Compiles

Review URL: http://codereview.chromium.org/7981026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@102311 0039d316-1c4b-4281-b951-d872f2087c98

remoting/client/DEPS

@@ -6,8 +6,4 @@ include_rules = [
 
   "+remoting/protocol",
   "+remoting/jingle_glue",
-
-  # TODO(sergeyu): Remove this dependency: crbug.com/74951 .
-  "+webkit/plugins/ppapi",
-  "+content/renderer/p2p",
 ]

remoting/client/ipc_host_resolver.cc

-// Copyright (c) 2011 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 "remoting/client/ipc_host_resolver.h"
-
-#include "base/bind.h"
-#include "content/renderer/p2p/host_address_request.h"
-#include "content/renderer/p2p/socket_dispatcher.h"
-#include "net/base/ip_endpoint.h"
-#include "jingle/glue/utils.h"
-
-namespace remoting {
-
-class IpcHostResolver : public HostResolver {
- public:
-  IpcHostResolver(content::P2PSocketDispatcher* socket_dispatcher)
-      : socket_dispatcher_(socket_dispatcher),
-        port_(0) {
-  }
-
-  virtual ~IpcHostResolver() {
-    if (request_)
-      request_->Cancel();
-  }
-
-  virtual void Resolve(const talk_base::SocketAddress& address) OVERRIDE {
-    if (address.IsUnresolved()) {
-      port_ = address.port();
-      request_ = new content::P2PHostAddressRequest(socket_dispatcher_);
-      request_->Request(address.hostname(), base::Bind(
-          &IpcHostResolver::OnDone, base::Unretained(this)));
-    } else {
-      SignalDone(this, address);
-    }
-  }
-
- private:
-  void OnDone(const net::IPAddressNumber& address) {
-    talk_base::SocketAddress socket_address;
-    if (address.empty() ||
-        !jingle_glue::IPEndPointToSocketAddress(
-            net::IPEndPoint(address, port_), &socket_address)) {
-      // Return nil address if the request has failed.
-      SignalDone(this, talk_base::SocketAddress());
-      return;
-    }
-
-    request_ = NULL;
-    SignalDone(this, socket_address);
-  }
-
-  content::P2PSocketDispatcher* socket_dispatcher_;
-  scoped_refptr<content::P2PHostAddressRequest> request_;
-  uint16 port_;
-};
-
-IpcHostResolverFactory::IpcHostResolverFactory(
-    content::P2PSocketDispatcher* socket_dispatcher)
-    : socket_dispatcher_(socket_dispatcher) {
-}
-
-IpcHostResolverFactory::~IpcHostResolverFactory() {
-}
-
-HostResolver* IpcHostResolverFactory::CreateHostResolver() {
-  return new IpcHostResolver(socket_dispatcher_);
-}
-
-}  // namespace remoting

remoting/client/ipc_host_resolver.h

-// Copyright (c) 2011 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.
-
-#ifndef REMOTING_CLIENT_IPC_HOST_RESOLVER_H_
-#define REMOTING_CLIENT_IPC_HOST_ADDRESS_RESOLVER_H_
-
-#include "base/compiler_specific.h"
-#include "remoting/jingle_glue/host_resolver.h"
-
-namespace content {
-class P2PSocketDispatcher;
-}  // namespace content
-
-namespace remoting {
-
-// Implementation of HostResolverFactory interface that works in
-// renderer.
-//
-// TODO(sergeyu): Move this class to content/renderer/p2p after
-// HostResolver interface is moved to libjingle.
-class IpcHostResolverFactory : public HostResolverFactory {
- public:
-  IpcHostResolverFactory(content::P2PSocketDispatcher* socket_dispatcher);
-  virtual ~IpcHostResolverFactory();
-
-  virtual HostResolver* CreateHostResolver() OVERRIDE;
-
- private:
-  content::P2PSocketDispatcher* socket_dispatcher_;
-
-  DISALLOW_COPY_AND_ASSIGN(IpcHostResolverFactory);
-};
-
-}  // namespace remoting
-
-#endif  // REMOTING_JINGLE_GLUE_HOST_RESOLVER_H_

remoting/client/plugin/chromoting_instance.cc

@@ -17,11 +17,6 @@
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
-// TODO(sergeyu): We should not depend on renderer here. Instead P2P
-// Pepper API should be used. Remove this dependency.
-// crbug.com/74951
-#include "content/renderer/p2p/ipc_network_manager.h"
-#include "content/renderer/p2p/ipc_socket_factory.h"
 #include "media/base/media.h"
 #include "ppapi/c/dev/ppb_query_policy_dev.h"
 #include "ppapi/cpp/completion_callback.h"
@@ -33,7 +28,6 @@
 #include "remoting/base/util.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/chromoting_client.h"
-#include "remoting/client/ipc_host_resolver.h"
 #include "remoting/client/plugin/chromoting_scriptable_object.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_port_allocator_session.h"
@@ -44,13 +38,6 @@
 #include "remoting/proto/auth.pb.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
-// TODO(sergeyu): This is a hack: plugin should not depend on webkit
-// glue. It is used here to get P2PPacketDispatcher corresponding to
-// the current RenderView. Use P2P Pepper API for connection and
-// remove these includes.
-// crbug.com/74951
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
-#include "webkit/plugins/ppapi/resource_tracker.h"
 
 namespace remoting {
 
@@ -170,8 +157,7 @@ void ChromotingInstance::Connect(const ClientConfig& config) {
   }
 
   host_connection_.reset(new protocol::ConnectionToHost(
-      context_.network_message_loop(), this, NULL, NULL, NULL, NULL,
-      enable_client_nat_traversal_));
+      context_.network_message_loop(), this, enable_client_nat_traversal_));
 
   input_handler_.reset(new PepperInputHandler(&context_,
                                               host_connection_.get(),

remoting/client/plugin/chromoting_instance.h

@@ -64,10 +64,10 @@ class ChromotingInstance : public pp::InstancePrivate {
   virtual ~ChromotingInstance();
 
   // pp::Instance interface.
-  virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip)
-      OVERRIDE;
-  virtual bool Init(uint32_t argc, const char* argn[], const char* argv[])
-      OVERRIDE;
+  virtual void DidChangeView(const pp::Rect& position,
+                             const pp::Rect& clip) OVERRIDE;
+  virtual bool Init(uint32_t argc, const char* argn[],
+                    const char* argv[]) OVERRIDE;
   virtual bool HandleInputEvent(const pp::InputEvent& event) OVERRIDE;
 
   // pp::InstancePrivate interface.

remoting/protocol/connection_to_host.cc

@@ -30,17 +30,9 @@ namespace protocol {
 ConnectionToHost::ConnectionToHost(
     base::MessageLoopProxy* message_loop,
     pp::Instance* pp_instance,
-    talk_base::NetworkManager* network_manager,
-    talk_base::PacketSocketFactory* socket_factory,
-    HostResolverFactory* host_resolver_factory,
-    PortAllocatorSessionFactory* session_factory,
     bool allow_nat_traversal)
     : message_loop_(message_loop),
       pp_instance_(pp_instance),
-      network_manager_(network_manager),
-      socket_factory_(socket_factory),
-      host_resolver_factory_(host_resolver_factory),
-      port_allocator_session_factory_(session_factory),
       allow_nat_traversal_(allow_nat_traversal),
       event_callback_(NULL),
       client_stub_(NULL),
@@ -80,7 +72,6 @@ void ConnectionToHost::Connect(scoped_refptr<XmppProxy> xmpp_proxy,
   host_jid_ = host_jid;
   host_public_key_ = host_public_key;
 
-  // Initialize |signal_strategy_|.
   JavascriptSignalStrategy* strategy = new JavascriptSignalStrategy(your_jid);
   strategy->AttachXmppProxy(xmpp_proxy);
   signal_strategy_.reset(strategy);
@@ -112,22 +103,7 @@ void ConnectionToHost::Disconnect(const base::Closure& shutdown_task) {
 void ConnectionToHost::InitSession() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
-  // Initialize |session_manager_|.
-  if (pp_instance_) {
-    session_manager_.reset(new PepperSessionManager(pp_instance_));
-  } else {
-    JingleSessionManager* session_manager =
-        JingleSessionManager::CreateSandboxed(
-            message_loop_, network_manager_.release(),
-            socket_factory_.release(), host_resolver_factory_.release(),
-            port_allocator_session_factory_.release());
-
-    // TODO(ajwong): Make this a command switch when we're more stable.
-    session_manager->set_allow_local_ips(true);
-
-    session_manager_.reset(session_manager);
-  }
-
+  session_manager_.reset(new PepperSessionManager(pp_instance_));
   session_manager_->Init(
       local_jid_, signal_strategy_.get(), this, NULL, "", allow_nat_traversal_);
 }
@@ -196,7 +172,6 @@ void ConnectionToHost::OnSessionStateChange(
       break;
 
     case Session::CONNECTED:
-      // Initialize reader and writer.
       video_reader_.reset(
           VideoReader::Create(message_loop_, session_->config()));
       video_reader_->Init(

remoting/protocol/connection_to_host.h

@@ -25,16 +25,9 @@ namespace pp {
 class Instance;
 }  // namespace pp
 
-namespace talk_base {
-class NetworkManager;
-class PacketSocketFactory;
-}  // namespace talk_base
-
 namespace remoting {
 
 class JingleThread;
-class HostResolverFactory;
-class PortAllocatorSessionFactory;
 class XmppProxy;
 class VideoPacket;
 
@@ -76,16 +69,8 @@ class ConnectionToHost : public SignalStrategy::StatusObserver,
     virtual void OnConnectionFailed(ConnectionToHost* conn) = 0;
   };
 
-  // Takes ownership of |network_manager| and |socket_factory|. Both
-  // |network_manager| and |socket_factory| may be set to NULL.
-  //
-  // TODO(sergeyu): Constructor shouldn't need thread here.
-  ConnectionToHost(base::MessageLoopProxy* network_message_loop,
+  ConnectionToHost(base::MessageLoopProxy* message_loop,
                    pp::Instance* pp_instance,
-                   talk_base::NetworkManager* network_manager,
-                   talk_base::PacketSocketFactory* socket_factory,
-                   HostResolverFactory* host_resolver_factory,
-                   PortAllocatorSessionFactory* session_factory,
                    bool allow_nat_traversal);
   virtual ~ConnectionToHost();
 
@@ -146,10 +131,6 @@ class ConnectionToHost : public SignalStrategy::StatusObserver,
 
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   pp::Instance* pp_instance_;
-  scoped_ptr<talk_base::NetworkManager> network_manager_;
-  scoped_ptr<talk_base::PacketSocketFactory> socket_factory_;
-  scoped_ptr<HostResolverFactory> host_resolver_factory_;
-  scoped_ptr<PortAllocatorSessionFactory> port_allocator_session_factory_;
   bool allow_nat_traversal_;
 
   std::string host_jid_;

remoting/remoting.gyp

@@ -544,8 +544,6 @@
         'client/frame_consumer.h',
         'client/input_handler.cc',
         'client/input_handler.h',
-        'client/ipc_host_resolver.cc',
-        'client/ipc_host_resolver.h',
         'client/rectangle_update_decoder.cc',
         'client/rectangle_update_decoder.h',
       ],