Use MessageLoopProxy for network message loop.

remoting/host/chromoting_host.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/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/curtain.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
@@ skipping 39 matching lines @@
       is_curtained_(false),
       is_it2me_(false) {
   DCHECK(desktop_environment_);
   desktop_environment_->set_host(this);
 }
 
 ChromotingHost::~ChromotingHost() {
 }
 
 void ChromotingHost::Start() {
-  if (MessageLoop::current() != context_->network_message_loop()) {
+  if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::Start, this));
     return;
   }
 
   LOG(INFO) << "Starting host";
   DCHECK(!signal_strategy_.get());
   DCHECK(access_verifier_.get());
 
   // Make sure this object is not started.
@@ skipping 65 matching lines @@
 }
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK_EQ(state_, kInitial);
   status_observers_.push_back(observer);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ConnectionToClient::EventHandler implementations
 void ChromotingHost::OnConnectionOpened(ConnectionToClient* connection) {
-  DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   VLOG(1) << "Connection to client established.";
   // TODO(wez): ChromotingHost shouldn't need to know about Me2Mom.
   if (is_it2me_) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::ProcessPreAuthentication, this,
                               make_scoped_refptr(connection)));
   }
 }
 
 void ChromotingHost::OnConnectionClosed(ConnectionToClient* connection) {
-  DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   VLOG(1) << "Connection to client closed.";
   context_->main_message_loop()->PostTask(
       FROM_HERE, base::Bind(&ChromotingHost::OnClientDisconnected, this,
                             make_scoped_refptr(connection)));
 }
 
 void ChromotingHost::OnConnectionFailed(ConnectionToClient* connection) {
-  DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   LOG(ERROR) << "Connection failed unexpectedly.";
   context_->main_message_loop()->PostTask(
       FROM_HERE, base::Bind(&ChromotingHost::OnClientDisconnected, this,
                             make_scoped_refptr(connection)));
 }
 
 void ChromotingHost::OnSequenceNumberUpdated(ConnectionToClient* connection,
                                              int64 sequence_number) {
   // Update the sequence number in ScreenRecorder.
   if (MessageLoop::current() != context_->main_message_loop()) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::OnSequenceNumberUpdated, this,
                               make_scoped_refptr(connection), sequence_number));
     return;
   }
 
   if (recorder_.get())
     recorder_->UpdateSequenceNumber(sequence_number);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // SignalStrategy::StatusObserver implementations
 void ChromotingHost::OnStateChange(
     SignalStrategy::StatusObserver::State state) {
-  DCHECK_EQ(MessageLoop::current(), context_->network_message_loop());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   if (state == SignalStrategy::StatusObserver::CONNECTED) {
     LOG(INFO) << "Host connected as " << local_jid_;
 
     // Create and start session manager.
     protocol::JingleSessionManager* server =
-        protocol::JingleSessionManager::CreateNotSandboxed();
+        protocol::JingleSessionManager::CreateNotSandboxed(
+            context_->network_message_loop());
     // TODO(ajwong): Make this a command switch when we're more stable.
     server->set_allow_local_ips(true);
 
     // Assign key and certificate to server.
     HostKeyPair key_pair;
     CHECK(key_pair.Load(config_))
         << "Failed to load server authentication data";
 
     server->Init(local_jid_, signal_strategy_.get(), this,
                  key_pair.CopyPrivateKey(), key_pair.GenerateCertificate(),
@@ skipping 12 matching lines @@
       (*it)->OnSignallingDisconnected();
     }
     // TODO(sergeyu): Don't shutdown the host and let the upper level
     // decide what needs to be done when signalling channel is
     // disconnected.
     Shutdown(NULL);
   }
 }
 
 void ChromotingHost::OnJidChange(const std::string& full_jid) {
-  DCHECK_EQ(MessageLoop::current(), context_->network_message_loop());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   local_jid_ = full_jid;
 }
 
 void ChromotingHost::OnSessionManagerInitialized() {
-  DCHECK_EQ(MessageLoop::current(), context_->network_message_loop());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   // Don't need to do anything here, just wait for incoming
   // connections.
 }
 
 void ChromotingHost::OnIncomingSession(
       protocol::Session* session,
       protocol::SessionManager::IncomingSessionResponse* response) {
-  DCHECK_EQ(MessageLoop::current(), context_->network_message_loop());
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   if (state_ != kStarted) {
     *response = protocol::SessionManager::DECLINE;
     return;
   }
 
   // If we are running Me2Mom and already have an authenticated client then
   // reject the connection immediately.
   if (is_it2me_ && AuthenticatedClientsCount() > 0) {
@@ skipping 59 matching lines @@
 }
 
 void ChromotingHost::set_protocol_config(
     protocol::CandidateSessionConfig* config) {
   DCHECK(config_.get());
   DCHECK_EQ(state_, kInitial);
   protocol_config_.reset(config);
 }
 
 void ChromotingHost::LocalMouseMoved(const gfx::Point& new_pos) {
-  if (MessageLoop::current() != context_->network_message_loop()) {
+  if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::LocalMouseMoved, this, new_pos));
     return;
   }
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     client->get()->LocalMouseMoved(new_pos);
   }
 }
 
@@ skipping 191 matching lines @@
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     if (client->get()->connection() == connection)
       break;
   }
   CHECK(client != clients_.end());
   client->get()->OnAuthorizationComplete(true);
 }
 
 void ChromotingHost::ShutdownNetwork() {
-  if (MessageLoop::current() != context_->network_message_loop()) {
+  if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::ShutdownNetwork, this));
     return;
   }
 
   // Stop chromotocol session manager.
   if (session_manager_.get()) {
     session_manager_->Close();
     session_manager_.reset();
   }
@@ skipping 46 matching lines @@
 
   for (std::vector<Task*>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     (*it)->Run();
     delete *it;
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting