Adding the AccessTokenFetcher and Environment class to the app remoting test

remoting/test/app_remoting_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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/launcher/unit_test_launcher.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/app_remoting_test_driver_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace switches {
-  const char kUserNameSwitchName[] = "username";
-  const char kAuthCodeSwitchName[] = "authcode";
-  const char kServiceEnvironmentSwitchName[] = "environment";
-  const char kHelpSwitchName[] = "help";
-  const char kSingleProcessTestsSwitchName[] = "single-process-tests";
+const char kAuthCodeSwitchName[] = "authcode";
+const char kHelpSwitchName[] = "help";
+const char kLoggingLevelSwitchName[] = "verbosity";
+const char kServiceEnvironmentSwitchName[] = "environment";
+const char kSingleProcessTestsSwitchName[] = "single-process-tests";
+const char kUserNameSwitchName[] = "username";
 }
 
 namespace {
 
 // Requested permissions needed for App Remoting tests.  The spaces in between
 // scope fragments are necessary and will be escaped properly before use.
 const char kAppRemotingAuthScopeValues[] =
     "https://www.googleapis.com/auth/appremoting.runapplication"
     " https://www.googleapis.com/auth/googletalk"
     " https://www.googleapis.com/auth/userinfo.email"
@@ skipping 27 matching lines @@
   printf("\nRequired Parameters:\n");
   printf("  %s: Specifies which account to use when running tests\n",
          switches::kUserNameSwitchName);
   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: Specifies the service api to use (dev|test) [default: dev]\n",
          switches::kServiceEnvironmentSwitchName);
+  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");
@@ skipping 59 matching lines @@
         base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
   }
 
   // Verify we received the required input from the command line.
   if (!command_line->HasSwitch(switches::kUserNameSwitchName)) {
     LOG(ERROR) << "No user name passed in, can't authenticate without that!";
     PrintUsage();
     return -1;
   }
 
+  std::string user_name;
+  user_name = command_line->GetSwitchValueASCII(switches::kUserNameSwitchName);
+  DVLOG(1) << "Running tests as: " << user_name;
+
+  std::string auth_code;
+  // Check to see if the user passed in a one time use auth_code for
+  // refreshing their credentials.
+  auth_code = command_line->GetSwitchValueASCII(switches::kAuthCodeSwitchName);
+
+  std::string service_environment;
+  // If the user passed in a service environment, use it, otherwise set a
+  // default value.
+  service_environment = command_line->GetSwitchValueASCII(
+      switches::kServiceEnvironmentSwitchName);
+  if (service_environment.empty()) {
+    // Default to the development service environment.
+    service_environment = "dev";
+  } else if (service_environment != "test" && service_environment != "dev") {
+    // Only two values are allowed, so validate them before proceeding.
+    LOG(ERROR) << "Invalid " << switches::kServiceEnvironmentSwitchName
+               << " argument passed in.";
+    PrintUsage();
+    return -1;
+  }
+
+  // Update the logging verbosity level is user specified one.
+  std::string verbosity_level;
+  verbosity_level =
+        command_line->GetSwitchValueASCII(switches::kLoggingLevelSwitchName);
+  if (!verbosity_level.empty()) {
+    // 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);
+  }
+
+  // Create and register our global test data object.  It will handle
+  // retrieving an access token for the user and spinning up VMs.
+  // The GTest framework will own the lifetime of this object once
+  // it is registered below.
+  scoped_ptr<remoting::test::AppRemotingTestDriverEnvironment> shared_data;
+
+  shared_data.reset(new remoting::test::AppRemotingTestDriverEnvironment(
+      user_name, service_environment));
+
+  if (!shared_data->Initialize(auth_code)) {
+    // If we failed to initialize our shared data object, then bail.
+    return -1;
+  }
+
+  // Since we've successfully set up our shared_data object, we'll assign the
+  // value to our global* and transfer ownership to the framework.
+  remoting::test::AppRemotingSharedData = shared_data.release();
+  testing::AddGlobalTestEnvironment(remoting::test::AppRemotingSharedData);
+
   // Because many tests may access the same remoting host(s), we need to run
   // the tests sequentially so they do not interfere with each other.
   return base::LaunchUnitTestsSerially(
       argc,
       argv,
       base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
 }