Always use chromium threads for IO in remoting host

remoting/jingle_glue/xmpp_signal_strategy.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/jingle_glue/xmpp_signal_strategy.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_util.h"
+#include "jingle/glue/chrome_async_socket.h"
+#include "jingle/glue/task_pump.h"
+#include "jingle/glue/xmpp_client_socket_factory.h"
 #include "jingle/notifier/base/gaia_token_pre_xmpp_auth.h"
-#include "remoting/jingle_glue/jingle_thread.h"
-#include "remoting/jingle_glue/xmpp_socket_adapter.h"
-#include "third_party/libjingle/source/talk/base/asyncsocket.h"
+#include "net/socket/client_socket_factory.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "third_party/libjingle/source/talk/base/thread.h"
 #include "third_party/libjingle/source/talk/xmpp/prexmppauth.h"
 #include "third_party/libjingle/source/talk/xmpp/saslcookiemechanism.h"
 
 namespace {
 
 const char kDefaultResourceName[] = "chromoting";
 
 // Use 58 seconds keep-alive interval, in case routers terminate
 // connections that are idle for more than a minute.
 const int kKeepAliveIntervalSeconds = 50;
 
+// Read buffer size used by ChromeAsyncSocket for read and write buffers. Most
+// of XMPP messages are smaller than 4kB.
+const size_t kReadBufferSize = 4096;
+const size_t kWriteBufferSize = 4096;
+
 void DisconnectXmppClient(buzz::XmppClient* client) {
   client->Disconnect();
 }
 
 }  // namespace
 
 namespace remoting {
 
-XmppSignalStrategy::XmppSignalStrategy(JingleThread* jingle_thread,
-                                       const std::string& username,
-                                       const std::string& auth_token,
-                                       const std::string& auth_token_service)
-   : thread_(jingle_thread),
+XmppSignalStrategy::XmppSignalStrategy(
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
+    const std::string& username,
+    const std::string& auth_token,
+    const std::string& auth_token_service)
+   : request_context_getter_(request_context_getter),
      username_(username),
      auth_token_(auth_token),
      auth_token_service_(auth_token_service),
      resource_name_(kDefaultResourceName),
      xmpp_client_(NULL),
      state_(DISCONNECTED),
      error_(OK) {
 }
 
 XmppSignalStrategy::~XmppSignalStrategy() {
   Disconnect();
 }
 
 void XmppSignalStrategy::Connect() {
   DCHECK(CalledOnValidThread());
 
   // Disconnect first if we are currently connected.
   Disconnect();
 
   buzz::XmppClientSettings settings;
   buzz::Jid login_jid(username_);
   settings.set_user(login_jid.node());
   settings.set_host(login_jid.domain());
   settings.set_resource(resource_name_);
   settings.set_use_tls(buzz::TLS_ENABLED);
   settings.set_token_service(auth_token_service_);
   settings.set_auth_token(buzz::AUTH_MECHANISM_GOOGLE_TOKEN, auth_token_);
   settings.set_server(talk_base::SocketAddress("talk.google.com", 5222));
 
-  buzz::AsyncSocket* socket = new XmppSocketAdapter(settings, false);
+  scoped_ptr<jingle_glue::XmppClientSocketFactory> socket_factory(
+      new jingle_glue::XmppClientSocketFactory(
+          net::ClientSocketFactory::GetDefaultFactory(),
+          net::SSLConfig(), request_context_getter_, false));
+  buzz::AsyncSocket* socket = new jingle_glue::ChromeAsyncSocket(
+    socket_factory.release(), kReadBufferSize, kWriteBufferSize);

[Wez, 2012/07/25 10:26:27]

Isn't it a waste of resources to have a separate factory per socket?

[Sergey Ulanov, 2012/07/25 18:50:49]

We never need more than one XmppSignalStrategy, so it doesn't matter here.

 
-  xmpp_client_ = new buzz::XmppClient(thread_->task_pump());
+  task_runner_.reset(new jingle_glue::TaskPump());
+  xmpp_client_ = new buzz::XmppClient(task_runner_.get());
   xmpp_client_->Connect(settings, "", socket, CreatePreXmppAuth(settings));
   xmpp_client_->SignalStateChange.connect(
       this, &XmppSignalStrategy::OnConnectionStateChanged);
   xmpp_client_->engine()->AddStanzaHandler(this, buzz::XmppEngine::HL_TYPE);
   xmpp_client_->Start();
 
   SetState(CONNECTING);
 }
 
 void XmppSignalStrategy::Disconnect() {
@@ skipping 138 matching lines @@
   std::string mechanism = notifier::GaiaTokenPreXmppAuth::kDefaultAuthMechanism;
   if (settings.token_service() == "oauth2") {
     mechanism = "X-OAUTH2";
   }
 
   return new notifier::GaiaTokenPreXmppAuth(
       jid.Str(), settings.auth_token(), settings.token_service(), mechanism);
 }
 
 }  // namespace remoting