Support for connecting to localhost on the chromoting test driver.

remoting/test/test_chromoting_client.cc

 // Copyright 2015 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/test/test_chromoting_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/token_fetcher_proxy.h"
 #include "remoting/protocol/authentication_method.h"
 #include "remoting/protocol/chromium_port_allocator.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/third_party_client_authenticator.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
+#include "remoting/test/host_info.h"
 #include "remoting/test/remote_host_info_fetcher.h"
 #include "remoting/test/test_video_renderer.h"
 
 namespace {
 
 const char kAppRemotingCapabilities[] =
     "rateLimitResizeRequests desktopShape sendInitialResolution googleDrive";
+const char kChromotingCapabilities[] = "";

[joedow, 2015/07/14 19:58:44]

This isn't really providing any value.  This probably should be a param passed
in to StartConnection().

[tonychun, 2015/07/15 17:32:50]

Done.

 
 const char kXmppHostName[] = "talk.google.com";
 const int kXmppPortNumber = 5222;
 
 // Used as the TokenFetcherCallback for App Remoting sessions.
 void FetchThirdPartyToken(
     const std::string& authorization_token,
     const std::string& shared_secret,
     const GURL& token_url,
     const std::string& host_public_key,
     const std::string& scope,
     base::WeakPtr<remoting::TokenFetcherProxy> token_fetcher_proxy) {
   VLOG(2)  << "FetchThirdPartyToken("
            << "token_url: " << token_url << ", "
            << "host_public_key: " << host_public_key << ", "
            << "scope: " << scope << ") Called";
 
   if (token_fetcher_proxy) {
     token_fetcher_proxy->OnTokenFetched(authorization_token, shared_secret);
     token_fetcher_proxy.reset();
   } else {
     LOG(ERROR) << "Invalid token fetcher proxy passed in";
   }
 }
 
+void FetchSecret(
+    const std::string& client_secret,
+    bool pairing_supported,
+    bool pairing_expected,
+    const remoting::protocol::SecretFetchedCallback& secret_fetched_callback) {
+  secret_fetched_callback.Run(client_secret);
+
+  // TODO(TonyChun): Pairing currently not supported for testing.

[joedow, 2015/07/14 19:58:44]

Why include this code?  The condition below actually succeeds if the binder and
caller of this function both pass false.

[tonychun, 2015/07/15 17:32:50]

Done.

+  if (pairing_supported == pairing_expected) {
+    VLOG(2) << "Pairing supported!";
+  } else {
+    VLOG(2) << "Pairing not supported!";
+  }
+}
+
 const char* ConnectionStateToFriendlyString(
     remoting::protocol::ConnectionToHost::State state) {
   switch (state) {
     case remoting::protocol::ConnectionToHost::INITIALIZING:
       return "INITIALIZING";
 
     case remoting::protocol::ConnectionToHost::CONNECTING:
       return "CONNECTING";
 
     case remoting::protocol::ConnectionToHost::AUTHENTICATED:
@@ skipping 68 matching lines @@
     : video_renderer_(video_renderer.Pass()) {
   TestChromotingClient();
 }
 
 TestChromotingClient::~TestChromotingClient() {
   // Ensure any connections are closed and the members are destroyed in the
   // appropriate order.
   EndConnection();
 }
 
+void TestChromotingClient::StartConnection(const std::string& user_name,
+                                           const std::string& access_token,
+                                           const std::string& client_pin,
+                                           const HostInfo& host_info) {

[joedow, 2015/07/14 19:58:44]

There is a lot of duplication here, can you refactor the StartConnection method
so that it shares code between Chromoting and App Remoting?  

[tonychun, 2015/07/15 17:32:50]

Done.

+  DCHECK(!user_name.empty());
+  DCHECK(!access_token.empty());
+  DCHECK(host_info.IsReadyForConnection());
+
+  // Required to establish a connection to the host.
+  jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
+
+  scoped_refptr<URLRequestContextGetter> request_context_getter;
+  request_context_getter = new URLRequestContextGetter(
+      base::ThreadTaskRunnerHandle::Get(),   // network_runner
+      base::ThreadTaskRunnerHandle::Get());  // file_runner
+
+  client_context_.reset(new ClientContext(base::ThreadTaskRunnerHandle::Get()));
+
+  // Check to see if the user passed in a customized video renderer.
+  if (!video_renderer_) {
+    video_renderer_.reset(new TestVideoRenderer());
+  }
+
+  chromoting_client_.reset(new ChromotingClient(client_context_.get(),
+                                                this,  // client_user_interface.
+                                                video_renderer_.get(),
+                                                nullptr));  // audio_player
+
+  if (test_connection_to_host_) {
+    chromoting_client_->SetConnectionToHostForTests(
+        test_connection_to_host_.Pass());
+  }
+
+  XmppSignalStrategy::XmppServerConfig xmpp_server_config;
+  xmpp_server_config.host = kXmppHostName;
+  xmpp_server_config.port = kXmppPortNumber;
+  xmpp_server_config.use_tls = true;
+  xmpp_server_config.username = user_name;
+  xmpp_server_config.auth_token = access_token;
+
+  // Set up the signal strategy.  This must outlive the client object.
+  signal_strategy_.reset(
+      new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
+                             request_context_getter, xmpp_server_config));
+
+  protocol::NetworkSettings network_settings(
+      protocol::NetworkSettings::NAT_TRAVERSAL_FULL);
+
+  scoped_ptr<protocol::ChromiumPortAllocator> port_allocator(
+      protocol::ChromiumPortAllocator::Create(request_context_getter,
+                                              network_settings));
+
+  scoped_ptr<protocol::TransportFactory> transport_factory(
+      new protocol::LibjingleTransportFactory(
+          signal_strategy_.get(), port_allocator.Pass(), network_settings,
+          protocol::TransportRole::CLIENT));
+
+  // Note: Only remote hosts without third party authenication methods
+  // can connect for now.
+  std::vector<protocol::AuthenticationMethod> auth_methods;
+  auth_methods.push_back(protocol::AuthenticationMethod::Spake2Pair());
+  auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
+      protocol::AuthenticationMethod::HMAC_SHA256));
+  auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
+      protocol::AuthenticationMethod::NONE));
+
+  protocol::FetchSecretCallback fetch_secret_callback =
+      base::Bind(&FetchSecret, client_pin, true);
+  scoped_ptr<protocol::Authenticator> authenticator(
+      new protocol::NegotiatingClientAuthenticator(
+          std::string(),      // client_pairing_id
+          std::string(),      // shared_secret
+          host_info.host_id,  // authentication_tag
+          fetch_secret_callback, nullptr, auth_methods));
+
+  chromoting_client_->Start(signal_strategy_.get(), authenticator.Pass(),
+                            transport_factory.Pass(), host_info.host_jid,
+                            kChromotingCapabilities);
+}
+
 void TestChromotingClient::StartConnection(
     const std::string& user_name,
     const std::string& access_token,
     const RemoteHostInfo& remote_host_info) {
   DCHECK(!user_name.empty());
   DCHECK(!access_token.empty());
   DCHECK(remote_host_info.IsReadyForConnection());
 
   // Required to establish a connection to the host.
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
@@ skipping 183 matching lines @@
   VLOG(1) << "TestChromotingClient::InjectClipboardEvent() Called";
 }
 
 void TestChromotingClient::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   VLOG(1) << "TestChromotingClient::SetCursorShape() Called";
 }
 
 }  // namespace test
 }  // namespace remoting