Support for connecting to localhost on the chromoting test driver.

remoting/test/chromoting_test_driver.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_suite.h"
 #include "base/test/test_switches.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "remoting/test/access_token_fetcher.h"
 #include "remoting/test/host_info.h"
 #include "remoting/test/host_list_fetcher.h"
 #include "remoting/test/refresh_token_store.h"
+#include "remoting/test/test_chromoting_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace switches {
 const char kAuthCodeSwitchName[] = "authcode";
+const char kClientPINSwitchName[] = "client-pin";

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

kClientPinSwitchName, also, is this a client pin?  Isn't it passed to the host?

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

Changed it to kPinSwitchName.

 const char kHelpSwitchName[] = "help";
 const char kHostNameSwitchName[] = "hostname";
 const char kLoggingLevelSwitchName[] = "verbosity";
 const char kRefreshTokenPathSwitchName[] = "refresh-token-path";
 const char kSingleProcessTestsSwitchName[] = "single-process-tests";
 const char kUserNameSwitchName[] = "username";
 }
 
 namespace {
 const char kChromotingAuthScopeValues[] =
@@ skipping 32 matching lines @@
          switches::kUserNameSwitchName);
   printf("  %s: Specifies which host to connect to when running tests\n",
          switches::kHostNameSwitchName);
   printf("\nOptional Parameters:\n");
   printf("  %s: Exchanged for a refresh and access token for authentication\n",
          switches::kAuthCodeSwitchName);
   printf("  %s: Displays additional usage information\n",
          switches::kHelpSwitchName);
   printf("  %s: Path to a JSON file containing username/refresh_token KVPs\n",
          switches::kRefreshTokenPathSwitchName);
+  printf("  %s: Used to authenticate a chromoting connection with the host\n",
+         switches::kClientPINSwitchName);
   printf("  %s: Specifies the optional logging level of the tool (0-3)."
          " [default: off]\n",
-      switches::kLoggingLevelSwitchName);
+         switches::kLoggingLevelSwitchName);
 }
 
 void PrintAuthCodeInfo() {
   printf("\n*******************************\n");
   printf("*** Auth Code Example Usage ***\n");
   printf("*******************************\n\n");
 
   printf("If this is the first time you are running the tool,\n");
   printf("you will need to provide an authorization code.\n");
   printf("This code will be exchanged for a long term refresh token which\n");
@@ skipping 106 matching lines @@
     // Turn on logging for the test_driver and remoting components.
     // This switch is parsed during logging::InitLogging.
     command_line->AppendSwitchASCII("vmodule",
                                     "*/remoting/*=" + verbosity_level);
     logging::LoggingSettings logging_settings;
     logging::InitLogging(logging_settings);
   }
 
   // The username is used to run the tests and determines which refresh token to
   // select in the refresh token file.
-  std::string username =
+  const std::string username =
       command_line->GetSwitchValueASCII(switches::kUserNameSwitchName);
-
   if (username.empty()) {
     LOG(ERROR) << "No username passed in, can't authenticate or run tests!";
     return -1;
   }
   VLOG(1) << "Running chromoting tests as: " << username;
 
   // Check to see if the user passed in a one time use auth_code for
   // refreshing their credentials.
   std::string auth_code =
       command_line->GetSwitchValueASCII(switches::kAuthCodeSwitchName);
 
-  base::FilePath refresh_token_path =
+  const base::FilePath refresh_token_path =
      command_line->GetSwitchValuePath(switches::kRefreshTokenPathSwitchName);
 
   // The hostname determines which host to initiate a session with from the list
   // returned from the directory service.
-  std::string hostname =
+  const std::string hostname =
       command_line->GetSwitchValueASCII(switches::kHostNameSwitchName);
-
   if (hostname.empty()) {
-    LOG(ERROR) << "No hostname passed in, connect to host requires hostname!";
+    LOG(ERROR) << "No hostname passed in, finding the host requires hostname!";
     return -1;
   }
   VLOG(1) << "Chromoting tests will connect to: " << hostname;
 
+  // For some connection, a client_pin is not required. Thus, I did not make it

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

s/connection/connections

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

Done.

+  // a requirement.

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

Actually, I'm wondering if this comment is needed.  I think that it is evident
that the param is not required since it is in the optional section of the help
output and you aren't checking its value here.

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

Removed.

+  const std::string client_pin =
+      command_line->GetSwitchValueASCII(switches::kClientPINSwitchName);
+
   // TODO(TonyChun): Move this logic into a shared environment class.
   scoped_ptr<remoting::test::RefreshTokenStore> refresh_token_store =
       remoting::test::RefreshTokenStore::OnDisk(username, refresh_token_path);
 
   std::string refresh_token = refresh_token_store->FetchRefreshToken();
   if (auth_code.empty() && refresh_token.empty()) {
     // RefreshTokenStore already logs which specific error occured.
     return -1;
   }
 
@@ skipping 20 matching lines @@
     access_token_fetcher.GetAccessTokenFromAuthCode(auth_code,
                                                     access_token_callback);
   } else {
     DCHECK(!refresh_token.empty());
     access_token_fetcher.GetAccessTokenFromRefreshToken(refresh_token,
                                                         access_token_callback);
   }
 
   run_loop->Run();
 
-  // RunLoop to handle callback from directory service.
+  // Reset runloop to use it to retrieve hostlist from directory service.
   run_loop.reset(new base::RunLoop());
 
   std::vector<remoting::test::HostInfo> hostlist;
   remoting::test::HostListFetcher::HostlistCallback hostlist_request_callback =
       base::Bind(&OnHostlistRetrieved, run_loop->QuitClosure(), &hostlist);
 
   // Uses the access token to get the hostlist from the directory service.
   remoting::test::HostListFetcher hostlist_fetcher;
   hostlist_fetcher.RetrieveHostlist(access_token, hostlist_request_callback);
 
   run_loop->Run();
 
+  run_loop.reset(new base::RunLoop());
+
+  base::Timer* timer = new base::Timer(true, false);

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

If this needs to be a pointer then use a scoped_ptr, but I think this can live
on the stack.

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

Done.

+
+  remoting::test::TestChromotingClient test_chromoting_client;
+
+  // Find the requested online host info and initiate a session.
+  for (auto host_info : hostlist) {

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

Instead of using a loop here, just use find() on hostlist, retrieve the index,
then create a connection if it was found.  No need for looping AFAICT

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

Done.

+    if (host_info.IsReadyForConnection() && host_info.host_name == hostname) {
+      // Total time to connect to a remote host before aborting the connection.
+      timer->Start(FROM_HERE, base::TimeDelta::FromSeconds(10),
+                    run_loop->QuitClosure());
+      test_chromoting_client.StartConnection(username, access_token,
+                                             client_pin, host_info);
+      run_loop->Run();
+      timer->Stop();
+      break;
+    }
+  }
+
+  test_chromoting_client.EndConnection();
+
   return 0;
 }