Access ChromotingHost::clients_ only on network thread.

remoting/host/plugin/host_script_object.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/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/sys_string_conversions.h"
@@ skipping 333 matching lines @@
 
 void HostNPScriptObject::OnAccessDenied() {
   DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts)
     DisconnectInternal();
 }
 
 void HostNPScriptObject::OnClientAuthenticated(const std::string& jid) {
-  DCHECK_EQ(MessageLoop::current(), host_context_.main_message_loop());
+  if (MessageLoop::current() != host_context_.main_message_loop()) {
+    host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
+        &HostNPScriptObject::OnClientAuthenticated,
+        base::Unretained(this), jid));
+    return;
+  }
 
   if (state_ == kDisconnecting) {
     // Ignore the new connection if we are disconnecting.
     return;
   }
 
   client_username_ = jid;
   size_t pos = client_username_.find('/');
   if (pos != std::string::npos)
     client_username_.replace(pos, std::string::npos, "");
   LOG(INFO) << "Client " << client_username_ << " connected.";
   SetState(kConnected);
 }
 
 void HostNPScriptObject::OnClientDisconnected(const std::string& jid) {
-  DCHECK_EQ(MessageLoop::current(), host_context_.main_message_loop());
+  if (MessageLoop::current() != host_context_.main_message_loop()) {
+    host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
+        &HostNPScriptObject::OnClientDisconnected,
+        base::Unretained(this), jid));
+    return;
+  }
 
   client_username_.clear();
 
   // Disconnect the host when a client disconnects.
   DisconnectInternal();
 }
 
 void HostNPScriptObject::OnShutdown() {
-  DCHECK_EQ(MessageLoop::current(), host_context_.main_message_loop());
+  if (MessageLoop::current() != host_context_.main_message_loop()) {
+    host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
+        &HostNPScriptObject::OnShutdown, base::Unretained(this)));
+    return;
+  }
 
   host_ = NULL;
   if (state_ != kDisconnected) {
     SetState(kDisconnected);
   }
 }
 
 // string uid, string auth_token
 bool HostNPScriptObject::Connect(const NPVariant* args,
                                  uint32_t arg_count,
@@ skipping 186 matching lines @@
 
     default:
       DCHECK(host_);
       SetState(kDisconnecting);
       host_->Shutdown(
           NewRunnableMethod(this, &HostNPScriptObject::OnShutdownFinished));
   }
 }
 
 void HostNPScriptObject::OnShutdownFinished() {
-  DCHECK_EQ(MessageLoop::current(), host_context_.main_message_loop());
+  if (MessageLoop::current() != host_context_.main_message_loop()) {
+    host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
+        &HostNPScriptObject::OnShutdownFinished, base::Unretained(this)));
+    return;
+  }
 
   disconnected_event_.Signal();
 }
 
 void HostNPScriptObject::OnNatPolicyUpdate(bool nat_traversal_enabled) {
   if (MessageLoop::current() != host_context_.main_message_loop()) {
     host_context_.main_message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                    base::Unretained(this), nat_traversal_enabled));
@@ skipping 222 matching lines @@
                                                uint32_t argCount) {
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
                                                    argCount, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
   return is_good;
 }
 
 }  // namespace remoting