Access Session::config() and Session::jid() on the correct thread only.

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"
@@ skipping 429 matching lines @@
   // about proper crash recovery and daemon mode.
   // TODO(wez): CurtainMode shouldn't be driven directly by ChromotingHost.
   if (is_it2me_ || enable == is_curtained_)
     return;
   desktop_environment_->curtain()->EnableCurtainMode(enable);
   is_curtained_ = enable;
 }
 
 void ChromotingHost::LocalLoginSucceeded(
     scoped_refptr<ConnectionToClient> connection) {
-  if (MessageLoop::current() != context_->main_message_loop()) {
-    context_->main_message_loop()->PostTask(
-        FROM_HERE, base::Bind(&ChromotingHost::LocalLoginSucceeded, this,
-                              connection));
-    return;
-  }
+  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
+  context_->main_message_loop()->PostTask(
+      FROM_HERE, base::Bind(&ChromotingHost::HandleLocalLoginSucceeded,
+                            this, connection, connection->session()->config(),
+                            connection->session()->jid()));

[Wez, 2011/09/10 01:10:03]

It seems kinda broken that we have to pull these out to pass to
HandleLocalLoginSucceeded, given that it has access to the ConnectionToClient.
:(

+}
+
+void ChromotingHost::HandleLocalLoginSucceeded(
+    scoped_refptr<ConnectionToClient> connection,
+    const protocol::SessionConfig& config,
+    const std::string& jid) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
   protocol::LocalLoginStatus* status = new protocol::LocalLoginStatus();
   status->set_success(true);
   connection->client_stub()->BeginSessionResponse(
       status, new DeleteTask<protocol::LocalLoginStatus>(status));
 
   // Disconnect all other clients.
   // Iterate over a copy of the list of clients, to avoid mutating the list
   // while iterating over it.
   ClientList clients_copy(clients_);
   for (ClientList::const_iterator client = clients_copy.begin();
        client != clients_copy.end(); client++) {
     ConnectionToClient* connection_other = client->get()->connection();
     if (connection_other != connection) {
       OnClientDisconnected(connection_other);
     }
   }
   // Those disconnections should have killed the screen recorder.
   CHECK(recorder_.get() == NULL);
 
   // Create a new RecordSession if there was none.
   if (!recorder_.get()) {
     // Then we create a ScreenRecorder passing the message loops that
     // it should run on.
-    Encoder* encoder = CreateEncoder(connection->session()->config());
+    Encoder* encoder = CreateEncoder(config);
 
     recorder_ = new ScreenRecorder(context_->main_message_loop(),
                                    context_->encode_message_loop(),
                                    context_->network_message_loop(),
                                    desktop_environment_->capturer(),
                                    encoder);
   }
 
   // Immediately add the connection and start the session.
   recorder_->AddConnection(connection);
   recorder_->Start();
   // Notify observers that there is at least one authenticated client.
   for (StatusObserverList::iterator it = status_observers_.begin();
        it != status_observers_.end(); ++it) {
     (*it)->OnClientAuthenticated(connection);
   }
   // TODO(jamiewalch): Tidy up actions to be taken on connect/disconnect,
   // including closing the connection on failure of a critical operation.
   EnableCurtainMode(true);
   if (is_it2me_) {
-    std::string username = connection->session()->jid();
+    std::string username = jid;
     size_t pos = username.find('/');
     if (pos != std::string::npos)
       username.replace(pos, std::string::npos, "");
     desktop_environment_->OnConnect(username);
   }
 }
 
 void ChromotingHost::LocalLoginFailed(
     scoped_refptr<ConnectionToClient> connection) {
   if (MessageLoop::current() != context_->main_message_loop()) {
@@ skipping 116 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