Retrieved Hostlist information from Directory service.

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 "testing/gtest/include/gtest/gtest.h"
 
 namespace switches {
 const char kAuthCodeSwitchName[] = "authcode";
 const char kHelpSwitchName[] = "help";
 const char kHostNameSwitchName[] = "hostname";
 const char kLoggingLevelSwitchName[] = "verbosity";
 const char kRefreshTokenPathSwitchName[] = "refresh-token-path";
 const char kSingleProcessTestsSwitchName[] = "single-process-tests";
@@ skipping 23 matching lines @@
           google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING),
           use_plus).c_str());
 }
 
 void PrintUsage() {
   printf("\n************************************\n");
   printf("*** Chromoting Test Driver Usage ***\n");
   printf("************************************\n");
 
   printf("\nUsage:\n");
-  printf("  chromoting_test_driver --username=<example@gmail.com> [options]\n");
+  printf("  chromoting_test_driver --username=<example@gmail.com> [options]"
+         " --hostname=<example hostname>\n");
   printf("\nRequired Parameters:\n");
   printf("  %s: Specifies which account to use when running tests\n",
          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: Displays additional usage information\n",
-         switches::kHelpSwitchName);
+  printf("  %s: Specifies the optional logging level of the tool (0-3)."
+         " [default: off]\n",
+      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");
   printf("will be stored locally and used to acquire a short lived access\n");
   printf("token to connect to the remoting service apis and establish a\n");
   printf("remote host connection.\n\n");
 
   printf("Note: You may need to repeat this step if the stored refresh token");
   printf("\n      has been revoked or expired.\n");
   printf("      Passing in the same auth code twice will result in an error\n");
 
-  printf(
-      "\nFollow these steps to produce an auth code:\n"
-      " - Open the Authorization URL link shown below in your browser\n"
-      " - Approve the requested permissions for the tool\n"
-      " - Copy the 'code' value in the redirected URL\n"
-      " - Run the tool and pass in copied auth code as a parameter\n");
+  printf("\nFollow these steps to produce an auth code:\n"
+         " - Open the Authorization URL link shown below in your browser\n"
+         " - Approve the requested permissions for the tool\n"
+         " - Copy the 'code' value in the redirected URL\n"
+         " - Run the tool and pass in copied auth code as a parameter\n");
 
   printf("\nAuthorization URL:\n");
   printf("%s\n", GetAuthorizationCodeUri().c_str());
 
   printf("\nRedirected URL Example:\n");
-  printf(
-      "https://chromoting-oauth.talkgadget.google.com/talkgadget/oauth/"
-      "chrome-remote-desktop/dev?code=4/AKtf...\n");
+  printf("https://chromoting-oauth.talkgadget.google.com/talkgadget/oauth/"
+         "chrome-remote-desktop/dev?code=4/AKtf...\n");
 
   printf("\nTool usage example with the newly created auth code:\n");
-  printf("chromoting_test_driver --%s=example@gmail.com --%s=4/AKtf...\n\n",
-         switches::kUserNameSwitchName, switches::kAuthCodeSwitchName);
+  printf("chromoting_test_driver --%s=example@gmail.com --%s=example_host_name"
+         " --%s=4/AKtf...\n\n",
+         switches::kUserNameSwitchName,
+         switches::kHostNameSwitchName,
+         switches::kAuthCodeSwitchName);
 }
 
 void PrintJsonFileInfo() {
   printf("\n****************************************\n");
   printf("*** Refresh Token File Example Usage ***\n");
   printf("****************************************\n\n");
 
   printf("In order to use this option, a valid JSON file must exist, be\n");
   printf("properly formatted, and contain a username/token KVP.\n");
   printf("Contents of example_file.json\n");
   printf("{\n");
   printf("  \"username1@fauxdomain.com\": \"1/3798Gsdf898shksdvfyi8sshad\",\n");
   printf("  \"username2@fauxdomain.com\": \"1/8974sdf87asdgadfgaerhfRsAa\",\n");
   printf("}\n\n");
 
   printf("\nTool usage example:\n");
-  printf("chromoting_test_driver --%s=%s --%s=./example_file.json\n\n",
+  printf("chromoting_test_driver --%s=%s --%s=example_host_name"
+         " --%s=./example_file.json\n\n",
          switches::kUserNameSwitchName, "username1@fauxdomain.com",
-         switches::kRefreshTokenPathSwitchName);
+         switches::kHostNameSwitchName, switches::kRefreshTokenPathSwitchName);
 }
 
-} // namespace
+}  // namespace
 
 void OnAccessTokenRetrieved(
     base::Closure done_closure,
-    const std::string& access_token,
-    const std::string& refresh_token) {
+    std::string* access_token,
+    const std::string& retrieved_access_token,
+    const std::string& retrieved_refresh_token) {
 
-  DVLOG(1) << "OnAccessTokenRetrieved() Called";
+  VLOG(1) << "OnAccessTokenRetrieved() Called";
+  DVLOG(1) << "Access Token: " << retrieved_access_token;

[joedow, 2015/07/09 02:41:18]

Can you use VLOG consistently?  DVLOG won't show up in release builds which is
what we run on the waterfall.

[tonychun, 2015/07/09 03:02:46]

Done.

 
-  DVLOG(1) << "Access Token: " << access_token;
+  *access_token = retrieved_access_token;
 
   done_closure.Run();
 }
 
+void OnHostlistRetrieved(
+    base::Closure done_closure,
+    std::vector<remoting::test::HostInfo>* hostlist,

[Sergey Ulanov, 2015/07/09 01:25:29]

Why do you need to use this parameter. It's not used in main(), i.e. main()
doesn't do anything with it after that.

[tonychun, 2015/07/09 03:02:46]

I will use it in my next CL, which will connect to a host through the
information provided by the host list. The purpose of this CL is to create the
HostListFetcher.

+    const std::vector<remoting::test::HostInfo>& retrieved_hostlist) {
+
+  VLOG(1) << "OnHostlistRetrieved() Called";
+
+  DCHECK(hostlist);
+
+  *hostlist = retrieved_hostlist;
+
+  DVLOG(1) << "There are " << hostlist->size() << " hosts in the hostlist";
+  done_closure.Run();
+}
+
 int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   base::TestSuite test_suite(argc, argv);
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   DCHECK(command_line);
 
   // Do not retry if tests fails.
   command_line->AppendSwitchASCII(switches::kTestLauncherRetryLimit, "0");
 
@@ skipping 33 matching lines @@
 
   // 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 =
      command_line->GetSwitchValuePath(switches::kRefreshTokenPathSwitchName);
 
   // The hostname determines which host to initiate a session with from the list
-  // returned from the Directory service.
+  // returned from the directory service.
   std::string hostname =
       command_line->GetSwitchValueASCII(switches::kHostNameSwitchName);
 
   if (hostname.empty()) {
     LOG(ERROR) << "No hostname passed in, connect to host requires hostname!";
     return -1;
   }
   DVLOG(1) << "Chromoting tests will connect to: " << hostname;
 
   // 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;
   }
 
   // Used for running network request tasks.
   // TODO(TonyChun): Move this logic into a shared environment class.
   base::MessageLoopForIO message_loop;
 
   // Uses the refresh token to get the access token from GAIA.
   remoting::test::AccessTokenFetcher access_token_fetcher;
 
-  base::RunLoop run_loop;
+  // A RunLoop that yields to the thread's MessageLoop.
+  scoped_ptr<base::RunLoop> run_loop;
 
+  // RunLoop to handle callback from GAIA.
+  run_loop.reset(new base::RunLoop());
+
+  std::string access_token;
   remoting::test::AccessTokenCallback access_token_callback =
-      base::Bind(&OnAccessTokenRetrieved, run_loop.QuitClosure());
+      base::Bind(&OnAccessTokenRetrieved,
+                 run_loop->QuitClosure(),
+                 &access_token);
 
   if (!auth_code.empty()) {
     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();
+  run_loop->Run();
+
+  // 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();

[Sergey Ulanov, 2015/07/09 01:25:29]

I think it would be cleaner to run message loop only once and do everything from
there. I.e. you can query host list from OnAccessTokenRetrieved(). No need to
quit and restart the message loop for that.

[tonychun, 2015/07/09 03:02:46]

I have to wait for the response from GAIA for the access token. Otherwise, the
driver crashes because we didn't wait for the access token to be set through the
callback function OnAccessTokenRetrieved();

[Sergey Ulanov, 2015/07/09 20:15:14]

Right. That doesn't mean you need to quit the loop every time. Once the access
token is received you can query hostlist from OnAccessTokenRetrieved() instead
of quitting the message loop

[tonychun, 2015/07/09 20:32:34]

Done.

 
   return 0;
 }