Don't depend on MessageLoopProxy in remoting protocol code.

remoting/protocol/libjingle_transport_factory.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 "remoting/protocol/libjingle_transport_factory.h"
 
-#include "base/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/transport_config.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 #include "third_party/libjingle/source/talk/base/network.h"
 #include "third_party/libjingle/source/talk/p2p/base/constants.h"
@@ skipping 78 matching lines @@
       ice_password_(talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH)) {
 }
 
 LibjingleStreamTransport::~LibjingleStreamTransport() {
   DCHECK(event_handler_);
   event_handler_->OnTransportDeleted(this);
   // Channel should be already destroyed if we were connected.
   DCHECK(!is_connected() || socket_.get() == NULL);
 
   if (channel_.get()) {
-    base::MessageLoopProxy::current()->DeleteSoon(
+    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
         FROM_HERE, channel_.release());
   }
 }
 
 void LibjingleStreamTransport::Initialize(
     const std::string& name,
     Transport::EventHandler* event_handler,
     scoped_ptr<ChannelAuthenticator> authenticator) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 161 matching lines @@
 }
 
 void LibjingleStreamTransport::NotifyConnectFailed() {
   DCHECK(!is_connected());
 
   socket_.reset();
 
   // This method may be called in response to a libjingle signal, so
   // libjingle objects must be deleted asynchronously.
   if (channel_.get()) {
-    base::MessageLoopProxy::current()->DeleteSoon(
+    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
         FROM_HERE, channel_.release());
   }
 
   authenticator_.reset();
 
   NotifyConnected(scoped_ptr<net::StreamSocket>(NULL));
 }
 
 }  // namespace
 
@@ skipping 10 matching lines @@
       socket_factory_(new talk_base::BasicPacketSocketFactory()),
       http_port_allocator_(NULL),
       port_allocator_(new cricket::BasicPortAllocator(
           network_manager_.get(), socket_factory_.get())),
       incoming_only_(false) {
 }
 
 LibjingleTransportFactory::~LibjingleTransportFactory() {
   // This method may be called in response to a libjingle signal, so
   // libjingle objects must be deleted asynchronously.
-  base::MessageLoopProxy::current()->DeleteSoon(
-      FROM_HERE, port_allocator_.release());
-  base::MessageLoopProxy::current()->DeleteSoon(
-      FROM_HERE, socket_factory_.release());
-  base::MessageLoopProxy::current()->DeleteSoon(
-      FROM_HERE, network_manager_.release());
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      base::ThreadTaskRunnerHandle::Get();
+  task_runner->DeleteSoon(FROM_HERE, port_allocator_.release());
+  task_runner->DeleteSoon(FROM_HERE, socket_factory_.release());
+  task_runner->DeleteSoon(FROM_HERE, network_manager_.release());
 }
 
 void LibjingleTransportFactory::SetTransportConfig(
     const TransportConfig& config) {
   if (http_port_allocator_) {
     std::vector<talk_base::SocketAddress> stun_hosts;
     talk_base::SocketAddress stun_address;
     if (stun_address.FromString(config.stun_server)) {
       stun_hosts.push_back(stun_address);
       http_port_allocator_->SetStunHosts(stun_hosts);
@@ skipping 15 matching lines @@
 }
 
 scoped_ptr<DatagramTransport>
 LibjingleTransportFactory::CreateDatagramTransport() {
   NOTIMPLEMENTED();
   return scoped_ptr<DatagramTransport>(NULL);
 }
 
 }  // namespace protocol
 }  // namespace remoting