Call XmppSignalStrategy::SetAuthInfo() on the right thread.

remoting/host/remoting_me2me_host.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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 130 matching lines @@
   int Run() {
     bool tokens_pending = false;
     if (!LoadConfig(file_io_thread_.message_loop_proxy(), &tokens_pending)) {
       return kInvalidHostConfigurationExitCode;
     }
     if (tokens_pending) {
       // If we have an OAuth refresh token, then XmppSignalStrategy can't
       // handle it directly, so refresh it asynchronously. A task will be
       // posted on the message loop to start watching the NAT policy when
       // the access token is available.
+      //
+      // TODO(sergeyu): Move this code to SignalingConnector.
       oauth_client_.Start(oauth_refresh_token_, this,
                           message_loop_.message_loop_proxy());
     } else {
       StartWatchingNatPolicy();
     }
 
 #if defined(OS_MACOSX)
     file_io_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
     return kSuccessExitCode;
   }
 
   // Overridden from OAuthClient::Delegate
   virtual void OnRefreshTokenResponse(const std::string& access_token,
                                       int expires) OVERRIDE {
     xmpp_auth_token_ = access_token;
     // If there's already a signal strategy object, update it ready for the
     // next time it calls Connect. If not, then this is the initial token
     // exchange, so proceed to the next stage of connection.
     if (signal_strategy_.get()) {
-      signal_strategy_->SetAuthInfo(xmpp_login_, xmpp_auth_token_,
-                                    xmpp_auth_service_);
+      context_->network_message_loop()->PostTask(
+          FROM_HERE, base::Bind(
+              &XmppSignalStrategy::SetAuthInfo,
+              base::Unretained(signal_strategy_.get()),

[Wez, 2012/04/13 22:40:52]

Looks like ChromotingContext gets torn down after SignalStrategy, so I don't
think you can safely use Unretained here.

[Jamie, 2012/04/13 22:41:08]

I think there's a race condition here. signal_strategy_ is declared after
context_ in the class definition, so the network thread will outlive it, making
this use of Unretained unsafe.

[Sergey Ulanov, 2012/04/13 23:43:50]

Yes, I realize this may be unsafe, but we never need to quit me2me host cleanly
anyway - Run() methods just call MessageLoop::Run() which runs until the process
is killed.
In either case, I plan to refactor this code and move OAuth refresh token
handling to SignalingConnector. This is just a quick and dirty fix to avoid
DCHECK.

+              xmpp_login_, xmpp_auth_token_, xmpp_auth_service_));
     } else {
       StartWatchingNatPolicy();
     }
   }
 
   virtual void OnOAuthError() OVERRIDE {
     LOG(ERROR) << "OAuth: invalid credentials.";
   }
 
  private:
@@ skipping 221 matching lines @@
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
                      int show_command) {
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif