[chromedriver] Load the automation extension as a component extension.

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 <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 25 matching lines @@
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/user_data_dir.h"
 #include "chrome/test/chromedriver/chrome/version.h"
 #include "chrome/test/chromedriver/chrome/web_view.h"
 #include "chrome/test/chromedriver/chrome/zip.h"
 #include "chrome/test/chromedriver/net/url_request_context_getter.h"
 #include "crypto/sha2.h"
 
 namespace {
 
-const char* kCommonSwitches[] = {
-  "ignore-certificate-errors", "metrics-recording-only"};
-
 Status UnpackAutomationExtension(const base::FilePath& temp_dir,
                                  base::FilePath* automation_extension) {
   std::string decoded_extension;
   if (!base::Base64Decode(kAutomationExtension, &decoded_extension))
     return Status(kUnknownError, "failed to base64decode automation extension");
 
   base::FilePath extension_zip = temp_dir.AppendASCII("internal.zip");
   int size = static_cast<int>(decoded_extension.length());
   if (file_util::WriteFile(extension_zip, decoded_extension.c_str(), size)
       != size) {
     return Status(kUnknownError, "failed to write automation extension zip");
   }
 
   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);
 }
 
-void AddSwitches(CommandLine* command,
-                 const char* switches[],
-                 size_t switch_count,
-                 const std::set<std::string>& exclude_switches) {
-  for (size_t i = 0; i < switch_count; ++i) {
-    if (exclude_switches.find(switches[i]) == exclude_switches.end())
-      command->AppendSwitch(switches[i]);
-  }
-}
-
 Status PrepareCommandLine(int port,
                           const Capabilities& capabilities,
+                          Switches* switches,
                           CommandLine* prepared_command,
                           base::ScopedTempDir* user_data_dir,
                           base::ScopedTempDir* extension_dir,
                           std::vector<std::string>* extension_bg_pages) {
-  CommandLine command = capabilities.command;
-  base::FilePath program = command.GetProgram();
+  base::FilePath program = capabilities.binary;
   if (program.empty()) {
     if (!FindChrome(&program))
       return Status(kUnknownError, "cannot find Chrome binary");
-    command.SetProgram(program);
   } else if (!base::PathExists(program)) {
     return Status(kUnknownError,
                   base::StringPrintf("no chrome binary at %" PRFilePath,
                                      program.value().c_str()));
   }
+  CommandLine command(program);
 
-  const char* excludable_switches[] = {
-      "disable-hang-monitor",
-      "disable-prompt-on-repost",
-      "full-memory-crash-report",
-      "no-first-run",
-      "disable-background-networking",
-      // TODO(chrisgao): Add "disable-sync" when chrome 30- is not supported.
-      // For chrome 30-, it leads to crash when opening chrome://settings.
-      "disable-web-resources",
-      "safebrowsing-disable-auto-update",
-      "safebrowsing-disable-download-protection",
-      "disable-client-side-phishing-detection",
-      "disable-component-update",
-      "disable-default-apps",
-  };
+  // TODO(chrisgao): Add "disable-sync" when chrome 30- is not supported.
+  // For chrome 30-, it leads to crash when opening chrome://settings.
+  switches->SetSwitch("disable-hang-monitor");
+  switches->SetSwitch("disable-prompt-on-repost");
+  switches->SetSwitch("full-memory-crash-report");
+  switches->SetSwitch("no-first-run");
+  switches->SetSwitch("disable-background-networking");
+  switches->SetSwitch("disable-web-resources");
+  switches->SetSwitch("safebrowsing-disable-auto-update");
+  switches->SetSwitch("safebrowsing-disable-download-protection");
+  switches->SetSwitch("disable-client-side-phishing-detection");
+  switches->SetSwitch("disable-component-update");
+  switches->SetSwitch("disable-default-apps");
+  switches->SetSwitch("enable-logging");
+  switches->SetSwitch("logging-level", "1");
+  switches->SetSwitch("password-store", "basic");
+  switches->SetSwitch("use-mock-keychain");
+  switches->SetSwitch("remote-debugging-port", base::IntToString(port));
 
-  AddSwitches(&command, excludable_switches, arraysize(excludable_switches),
-              capabilities.exclude_switches);
-  AddSwitches(&command, kCommonSwitches, arraysize(kCommonSwitches),
-              capabilities.exclude_switches);
-
-  command.AppendSwitch("enable-logging");
-  command.AppendSwitchASCII("logging-level", "1");
-  command.AppendSwitchASCII("password-store", "basic");
-  command.AppendSwitch("use-mock-keychain");
-  command.AppendSwitchASCII("remote-debugging-port", base::IntToString(port));
-
-  if (!command.HasSwitch("user-data-dir")) {
+  if (!switches->HasSwitch("user-data-dir")) {
     command.AppendArg("about:blank");
     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(), 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(capabilities.extensions,
                                               extension_dir->path(),
                                               true,
-                                              &command,
+                                              switches,
                                               extension_bg_pages);
   if (status.IsError())
     return status;
 
+  switches->AppendToCommandLine(&command);
   *prepared_command = command;
   return Status(kOk);
 }
 
 Status WaitForDevToolsAndCheckVersion(
     int port,
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
     Log* log,
     scoped_ptr<DevToolsHttpClient>* user_client) {
@@ skipping 40 matching lines @@
       log));
   return Status(kOk);
 }
 
 Status LaunchDesktopChrome(
     URLRequestContextGetter* context_getter,
     int port,
     const SyncWebSocketFactory& socket_factory,
     Log* log,
     const Capabilities& capabilities,
+    Switches* switches,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   CommandLine command(CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
   std::vector<std::string> extension_bg_pages;
   Status status = PrepareCommandLine(port,
                                      capabilities,
+                                     switches,
                                      &command,
                                      &user_data_dir,
                                      &extension_dir,
                                      &extension_bg_pages);
   if (status.IsError())
     return status;
 
   base::LaunchOptions options;
 
 #if !defined(OS_WIN)
@@ skipping 77 matching lines @@
   *chrome = chrome_desktop.Pass();
   return Status(kOk);
 }
 
 Status LaunchAndroidChrome(
     URLRequestContextGetter* context_getter,
     int port,
     const SyncWebSocketFactory& socket_factory,
     Log* log,
     const Capabilities& capabilities,
+    Switches* switches,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     DeviceManager* device_manager,
     scoped_ptr<Chrome>* chrome) {
   Status status(kOk);
   scoped_ptr<Device> device;
   if (capabilities.android_device_serial.empty()) {
     status = device_manager->AcquireDevice(&device);
   } else {
     status = device_manager->AcquireSpecificDevice(
         capabilities.android_device_serial, &device);
   }
   if (!status.IsOk())
     return status;
 
-  std::string args(capabilities.android_args);
-  for (size_t i = 0; i < arraysize(kCommonSwitches); i++)
-    args += "--" + std::string(kCommonSwitches[i]) + " ";
-  args += "--disable-fre --enable-remote-debugging";
-
+  switches->SetSwitch("disable-fre");
+  switches->SetSwitch("enable-remote-debugging");
   status = device->StartApp(capabilities.android_package,
                             capabilities.android_activity,
                             capabilities.android_process,
-                            args, port);
+                            switches->ToString(), port);
   if (!status.IsOk()) {
     device->StopApp();
     return status;
   }
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   status = WaitForDevToolsAndCheckVersion(port,
                                           context_getter,
                                           socket_factory,
                                           log,
@@ skipping 15 matching lines @@
     Log* log,
     DeviceManager* device_manager,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
 
   if (capabilities.IsExistingBrowser()) {
     return LaunchExistingChromeSession(
         context_getter, capabilities.existing_browser_port, socket_factory,
         log, capabilities, devtools_event_listeners, chrome);
-  } else if (capabilities.IsAndroid()) {
+  }
+
+
+  Switches switches = capabilities.switches;
+  const char* kCommonSwitches[] = {
+      "ignore-certificate-errors", "metrics-recording-only"};
+  for (size_t i = 0; i < arraysize(kCommonSwitches); i++)
+    switches.SetSwitch(kCommonSwitches[i]);
+
+  if (capabilities.IsAndroid()) {
     return LaunchAndroidChrome(
         context_getter, port, socket_factory, log, capabilities,
-        devtools_event_listeners, device_manager, chrome);
+        &switches, devtools_event_listeners, device_manager, chrome);
   } else {
     return LaunchDesktopChrome(
         context_getter, port, socket_factory, log, capabilities,
-        devtools_event_listeners, chrome);
+        &switches, devtools_event_listeners, chrome);
   }
 }
 
 namespace internal {
 
 void ConvertHexadecimalToIDAlphabet(std::string* id) {
   for (size_t i = 0; i < id->size(); ++i) {
     int val;
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
@@ skipping 96 matching lines @@
   Status status = GetExtensionBackgroundPage(manifest, id, &bg_page_tmp);
   if (status.IsError())
     return status;
 
   *path = extension_dir;
   if (bg_page_tmp.size())
     *bg_page = bg_page_tmp;
   return Status(kOk);
 }
 
+void UpdateExtensionSwitch(Switches* switches,
+                           const char name[],
+                           const base::FilePath::StringType& extension) {
+  base::FilePath::StringType value = switches->GetSwitchValueNative(name);
+  if (value.length())
+    value += FILE_PATH_LITERAL(",");
+  value += extension;
+  switches->SetSwitch(name, value);
+}
+
 Status ProcessExtensions(const std::vector<std::string>& extensions,
                          const base::FilePath& temp_dir,
                          bool include_automation_extension,
-                         CommandLine* command,
+                         Switches* switches,
                          std::vector<std::string>* bg_pages) {
   std::vector<std::string> bg_pages_tmp;
   std::vector<base::FilePath::StringType> extension_paths;
   for (size_t i = 0; i < extensions.size(); ++i) {
     base::FilePath path;
     std::string bg_page;
     Status status = ProcessExtension(extensions[i], temp_dir, &path, &bg_page);
     if (status.IsError()) {
       return Status(
           kUnknownError,
           base::StringPrintf("cannot process extension #%" PRIuS, i + 1),
           status);
     }
     extension_paths.push_back(path.value());
     if (bg_page.length())
       bg_pages_tmp.push_back(bg_page);
   }
 
   if (include_automation_extension) {
     base::FilePath automation_extension;
     Status status = UnpackAutomationExtension(temp_dir, &automation_extension);
     if (status.IsError())
       return status;
-    if (command->HasSwitch("disable-extensions")) {
-      command->AppendSwitchNative("load-component-extension",
-                                  automation_extension.value());
+    if (switches->HasSwitch("disable-extensions")) {
+      UpdateExtensionSwitch(switches, "load-component-extension",
+                            automation_extension.value());
     } else {
       extension_paths.push_back(automation_extension.value());
     }
   }
 
   if (extension_paths.size()) {
     base::FilePath::StringType extension_paths_value = JoinString(
         extension_paths, FILE_PATH_LITERAL(','));
-    command->AppendSwitchNative("load-extension", extension_paths_value);
+    UpdateExtensionSwitch(switches, "load-extension", extension_paths_value);
   }
   bg_pages->swap(bg_pages_tmp);
   return Status(kOk);
 }
 
 Status WritePrefsFile(
     const std::string& template_string,
     const base::DictionaryValue* custom_prefs,
     const base::FilePath& path) {
   int code;
@@ skipping 47 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