Use P2P Transport API by default.

remoting/client/plugin/chromoting_instance.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/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 138 matching lines @@
   view_proxy_ = new PepperViewProxy(this, view_.get(), plugin_message_loop_);
   rectangle_decoder_ = new RectangleUpdateDecoder(
       context_.decode_message_loop(), view_proxy_);
 
   // Default to a medium grey.
   view_->SetSolidFill(0xFFCDCDCD);
 
   return true;
 }
 
-void ChromotingInstance::Connect(const ClientConfig& config, bool use_p2p_api) {
+void ChromotingInstance::Connect(const ClientConfig& config) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
   // This can only happen at initialization if the Javascript connect call
   // occurs before the enterprise policy is read.  We are guaranteed that the
   // enterprise policy is pushed at least once, we we delay the connect call.
   if (!initial_policy_received_) {
     LOG(INFO) << "Delaying connect until initial policy is read.";
     delayed_connect_.reset(
-        task_factory_.NewRunnableMethod(&ChromotingInstance::Connect,
-                                        config, use_p2p_api));
+        task_factory_.NewRunnableMethod(&ChromotingInstance::Connect, config));
     return;
   }
 
-  webkit::ppapi::PluginInstance* plugin_instance =
-      webkit::ppapi::ResourceTracker::Get()->GetInstance(pp_instance());
-
-  if (use_p2p_api) {
-    host_connection_.reset(new protocol::ConnectionToHost(
-        context_.network_message_loop(), this, NULL, NULL, NULL, NULL,
-        enable_client_nat_traversal_));
-  } else {
-    content::P2PSocketDispatcher* socket_dispatcher =
-        plugin_instance->delegate()->GetP2PSocketDispatcher();
-
-    content::IpcNetworkManager* network_manager = NULL;
-    content::IpcPacketSocketFactory* socket_factory = NULL;
-    HostResolverFactory* host_resolver_factory = NULL;
-    PortAllocatorSessionFactory* session_factory =
-        CreatePepperPortAllocatorSessionFactory(
-            this, plugin_message_loop_, context_.network_message_loop());
-
-    // If we don't have socket dispatcher for IPC (e.g. P2P API is
-    // disabled), then JingleSessionManager will try to use physical sockets.
-    if (socket_dispatcher) {
-      VLOG(1) << "Creating IpcNetworkManager and IpcPacketSocketFactory.";
-      network_manager = new content::IpcNetworkManager(socket_dispatcher);
-      socket_factory = new content::IpcPacketSocketFactory(socket_dispatcher);
-      host_resolver_factory = new IpcHostResolverFactory(socket_dispatcher);
-    }
-
-    host_connection_.reset(new protocol::ConnectionToHost(
-        context_.network_message_loop(), NULL, network_manager, socket_factory,
-        host_resolver_factory, session_factory, enable_client_nat_traversal_));
-  }
+  host_connection_.reset(new protocol::ConnectionToHost(
+      context_.network_message_loop(), this, NULL, NULL, NULL, NULL,
+      enable_client_nat_traversal_));

[Wez, 2011/09/22 11:24:56]

Will the ConnectionToHost be updated in a subsequent CL, to remove the no-longer
used constructor parameters?

[Sergey Ulanov, 2011/09/22 17:07:45]

Yes.

 
   input_handler_.reset(new PepperInputHandler(&context_,
                                               host_connection_.get(),
                                               view_proxy_));
 
   client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
                                      view_proxy_, rectangle_decoder_.get(),
                                      input_handler_.get(), NULL));
 
   LOG(INFO) << "Connecting.";
@@ skipping 341 matching lines @@
   }
 
   initial_policy_received_ = true;
   enable_client_nat_traversal_ = traversal_policy;
 
   if (delayed_connect_.get())
     plugin_message_loop_->PostTask(FROM_HERE, delayed_connect_.release());
 }
 
 }  // namespace remoting