[chromedriver] Implement proxy capability.

chrome/test/chromedriver/chrome_launcher.cc

 // Copyright (c) 2013 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 "chrome/test/chromedriver/chrome_launcher.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 38 matching lines @@
 
   base::FilePath extension_dir = temp_dir.AppendASCII("internal");
   if (!zip::Unzip(extension_zip, extension_dir))
     return Status(kUnknownError, "failed to unzip automation extension");
 
   *automation_extension = extension_dir;
   return Status(kOk);
 }
 
 Status PrepareCommandLine(int port,
-                          const base::FilePath& exe,
-                          const base::ListValue* args,
-                          const base::ListValue* extensions,
-                          const base::DictionaryValue* prefs,
-                          const base::DictionaryValue* local_state,
+                          const Capabilities& capabilities,
                           CommandLine* prepared_command,
                           base::ScopedTempDir* user_data_dir,
                           base::ScopedTempDir* extension_dir) {
-  base::FilePath program = exe;
+  CommandLine command = capabilities.command;
+  base::FilePath program = command.GetProgram();
   if (program.empty()) {
     if (!FindChrome(&program))
       return Status(kUnknownError, "cannot find Chrome binary");
+    command.SetProgram(program);
+  } else if (!file_util::PathExists(program)) {
+    return Status(kUnknownError,
+                  base::StringPrintf("no chrome binary at %" PRFilePath,
+                                     program.value().c_str()));
   }
   LOG(INFO) << "Using chrome from " << program.value();
 
-  CommandLine command(program);
   command.AppendSwitchASCII("remote-debugging-port", base::IntToString(port));
   command.AppendSwitch("no-first-run");
   command.AppendSwitch("enable-logging");
   command.AppendSwitchASCII("logging-level", "1");
   command.AppendArg("data:text/html;charset=utf-8,");
 
-  if (args) {
-    Status status = internal::ProcessCommandLineArgs(args, &command);
-    if (status.IsError())
-      return status;
-  }
-
   if (!command.HasSwitch("user-data-dir")) {
     if (!user_data_dir->CreateUniqueTempDir())
       return Status(kUnknownError, "cannot create temp dir for user data dir");
     command.AppendSwitchPath("user-data-dir", user_data_dir->path());
     Status status = internal::PrepareUserDataDir(
-        user_data_dir->path(), prefs, local_state);
+        user_data_dir->path(), capabilities.prefs.get(),
+        capabilities.local_state.get());
     if (status.IsError())
       return status;
   }
 
   if (!extension_dir->CreateUniqueTempDir()) {
     return Status(kUnknownError,
                   "cannot create temp dir for unpacking extensions");
   }
   Status status = internal::ProcessExtensions(
-      extensions, extension_dir->path(), true, &command);
+      capabilities.extensions, extension_dir->path(), true, &command);
   if (status.IsError())
     return status;
 
   *prepared_command = command;
   return Status(kOk);
 }
 
 Status ParseAndCheckVersion(const std::string& devtools_version,
                             std::string* version,
                             int* build_no) {
@@ skipping 61 matching lines @@
     client->GetWebViewsInfo(&views_info);
     if (views_info.GetSize()) {
       *user_client = client.Pass();
       return Status(kOk);
     }
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
   }
   return Status(kUnknownError, "unable to discover open pages");
 }
 
-}  // namespace
-
 Status LaunchDesktopChrome(URLRequestContextGetter* context_getter,
                            int port,
                            const SyncWebSocketFactory& socket_factory,
-                           const base::FilePath& exe,
-                           const base::ListValue* args,
-                           const base::ListValue* extensions,
-                           const base::DictionaryValue* prefs,
-                           const base::DictionaryValue* local_state,
-                           const std::string& log_path,
+                           const Capabilities& capabilities,
                            scoped_ptr<Chrome>* chrome) {
   CommandLine command(CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
-  PrepareCommandLine(port, exe, args, extensions, prefs, local_state,
+  PrepareCommandLine(port, capabilities,
                      &command, &user_data_dir, &extension_dir);
   base::LaunchOptions options;
 
 #if !defined(OS_WIN)
   base::EnvironmentVector environ;
-  if (!log_path.empty()) {
-    environ.push_back(base::EnvironmentVector::value_type("CHROME_LOG_FILE",
-                                                          log_path));
+  if (!capabilities.log_path.empty()) {
+    environ.push_back(
+        base::EnvironmentVector::value_type("CHROME_LOG_FILE",
+                                            capabilities.log_path));
     options.environ = &environ;
   }
 #endif
 
   base::ProcessHandle process;
   if (!base::LaunchProcess(command, options, &process))
     return Status(kUnknownError, "chrome failed to start");
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   std::string version;
@@ skipping 38 matching lines @@
   }
   chrome->reset(new ChromeDesktopImpl(
       devtools_client.Pass(), version, build_no, process, &user_data_dir,
       &extension_dir));
   return Status(kOk);
 }
 
 Status LaunchAndroidChrome(URLRequestContextGetter* context_getter,
                            int port,
                            const SyncWebSocketFactory& socket_factory,
-                           const std::string& package_name,
+                           const Capabilities& capabilities,
                            scoped_ptr<Chrome>* chrome) {
   // TODO(frankf): Figure out how this should be installed to
   // make this work for all platforms.
   base::FilePath adb_commands(FILE_PATH_LITERAL("adb_commands.py"));
   CommandLine command(adb_commands);
-  command.AppendSwitchASCII("package", package_name);
+  command.AppendSwitchASCII("package", capabilities.android_package);
   command.AppendSwitch("launch");
   command.AppendSwitchASCII("port", base::IntToString(port));
 
   std::string output;
   if (!base::GetAppOutput(command, &output)) {
     if (output.empty())
       return Status(
           kUnknownError,
           "failed to run adb_commands.py. Make sure it is set in PATH.");
     else
       return Status(kUnknownError, "android app failed to start.\n" + output);
   }
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   std::string version;
   int build_no;
   Status status = WaitForDevToolsAndCheckVersion(
       port, context_getter, socket_factory, &devtools_client, &version,
       &build_no);
   if (status.IsError())
     return status;
 
   chrome->reset(new ChromeAndroidImpl(
       devtools_client.Pass(), version, build_no));
   return Status(kOk);
 }
 
+}  // namespace
+
+Status LaunchChrome(URLRequestContextGetter* context_getter,
+                    int port,
+                    const SyncWebSocketFactory& socket_factory,
+                    const Capabilities& capabilities,
+                    scoped_ptr<Chrome>* chrome) {
+  if (capabilities.IsAndroid()) {
+    return LaunchAndroidChrome(
+        context_getter, port, socket_factory, capabilities, chrome);
+  } else {
+    return LaunchDesktopChrome(
+        context_getter, port, socket_factory, capabilities, chrome);
+  }
+}
+
 namespace internal {
 
-Status ProcessCommandLineArgs(const base::ListValue* args,
-                              CommandLine* command) {
-  for (size_t i = 0; i < args->GetSize(); ++i) {
-    std::string arg_string;
-    if (!args->GetString(i, &arg_string))
-      return Status(kUnknownError, "invalid chrome command line argument");
-    size_t separator_index = arg_string.find("=");
-    if (separator_index != std::string::npos) {
-      CommandLine::StringType arg_string_native;
-      if (!args->GetString(i, &arg_string_native))
-        return Status(kUnknownError, "invalid chrome command line argument");
-      command->AppendSwitchNative(
-          arg_string.substr(0, separator_index),
-          arg_string_native.substr(separator_index + 1));
-    } else {
-      command->AppendSwitch(arg_string);
-    }
-  }
-  return Status(kOk);
-}
-
-Status ProcessExtensions(const base::ListValue* extensions,
+Status ProcessExtensions(const std::vector<std::string>& extensions,
                          const base::FilePath& temp_dir,
                          bool include_automation_extension,
                          CommandLine* command) {
   std::vector<base::FilePath::StringType> extension_paths;
-  for (size_t i = 0; i < (extensions ? extensions->GetSize() : 0); ++i) {
+  size_t count = 0;
+  for (std::vector<std::string>::const_iterator it = extensions.begin();
+       it != extensions.end(); ++it) {
     std::string extension_base64;
-    if (!extensions->GetString(i, &extension_base64)) {
-      return Status(kUnknownError,
-                    "each extension must be a base64 encoded string");
-    }
-
     // Decodes extension string.
     // Some WebDriver client base64 encoders follow RFC 1521, which require that
     // 'encoded lines be no more than 76 characters long'. Just remove any
     // newlines.
-    RemoveChars(extension_base64, "\n", &extension_base64);
+    RemoveChars(*it, "\n", &extension_base64);
     std::string decoded_extension;
     if (!base::Base64Decode(extension_base64, &decoded_extension))
       return Status(kUnknownError, "failed to base64 decode extension");
 
     // Writes decoded extension into a temporary .crx file.
     base::ScopedTempDir temp_crx_dir;
     if (!temp_crx_dir.CreateUniqueTempDir())
       return Status(kUnknownError,
                     "cannot create temp dir for writing extension CRX file");
     base::FilePath extension_crx = temp_crx_dir.path().AppendASCII("temp.crx");
     int size = static_cast<int>(decoded_extension.length());
     if (file_util::WriteFile(extension_crx, decoded_extension.c_str(), size)
-        != size)
+        != size) {
       return Status(kUnknownError, "failed to write extension file");
+    }
 
     // Unzips the temporary .crx file.
+    count++;
     base::FilePath extension_dir = temp_dir.AppendASCII(
-        base::StringPrintf("extension%" PRIuS, i));
+        base::StringPrintf("extension%" PRIuS, count));
     if (!zip::Unzip(extension_crx, extension_dir))
       return Status(kUnknownError, "failed to unzip the extension CRX file");
     extension_paths.push_back(extension_dir.value());
   }
 
   if (include_automation_extension) {
     base::FilePath automation_extension;
     Status status = UnpackAutomationExtension(temp_dir, &automation_extension);
     if (status.IsError())
       return status;
@@ skipping 59 matching lines @@
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (file_util::WriteFile(
           user_data_dir.AppendASCII("First Run"), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal