chrome/test/chromedriver/chrome_launcher.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/test/chromedriver/chrome_launcher.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/base64.h"
  11 #include "base/basictypes.h"
  12 #include "base/bind.h"
  13 #include "base/command_line.h"
  14 #include "base/files/file_path.h"
  15 #include "base/files/file_util.h"
  16 #include "base/files/scoped_file.h"
  17 #include "base/format_macros.h"
  18 #include "base/json/json_reader.h"
  19 #include "base/json/json_writer.h"
  20 #include "base/logging.h"
  21 #include "base/process/kill.h"
  22 #include "base/process/launch.h"
  23 #include "base/strings/string_number_conversions.h"
  24 #include "base/strings/string_util.h"
  25 #include "base/strings/stringprintf.h"
  26 #include "base/strings/utf_string_conversions.h"
  27 #include "base/threading/platform_thread.h"
  28 #include "base/time/time.h"
  29 #include "base/values.h"
  30 #include "chrome/common/chrome_constants.h"
  31 #include "chrome/test/chromedriver/chrome/chrome_android_impl.h"
  32 #include "chrome/test/chromedriver/chrome/chrome_desktop_impl.h"
  33 #include "chrome/test/chromedriver/chrome/chrome_finder.h"
  34 #include "chrome/test/chromedriver/chrome/chrome_remote_impl.h"
  35 #include "chrome/test/chromedriver/chrome/device_manager.h"
  36 #include "chrome/test/chromedriver/chrome/devtools_client_impl.h"
  37 #include "chrome/test/chromedriver/chrome/devtools_event_listener.h"
  38 #include "chrome/test/chromedriver/chrome/devtools_http_client.h"
  39 #include "chrome/test/chromedriver/chrome/embedded_automation_extension.h"
  40 #include "chrome/test/chromedriver/chrome/status.h"
  41 #include "chrome/test/chromedriver/chrome/user_data_dir.h"
  42 #include "chrome/test/chromedriver/chrome/version.h"
  43 #include "chrome/test/chromedriver/chrome/web_view.h"
  44 #include "chrome/test/chromedriver/net/port_server.h"
  45 #include "chrome/test/chromedriver/net/url_request_context_getter.h"
  46 #include "crypto/rsa_private_key.h"
  47 #include "crypto/sha2.h"
  48 #include "third_party/zlib/google/zip.h"
  49
  50 #if defined(OS_POSIX)
  51 #include <fcntl.h>
  52 #include <sys/stat.h>
  53 #include <sys/types.h>
  54 #endif
  55
  56 namespace {
  57
  58 const char* kCommonSwitches[] = {
  59     "ignore-certificate-errors", "metrics-recording-only"};
  60
  61 #if defined(OS_LINUX)
  62 const char* kEnableCrashReport = "enable-crash-reporter-for-testing";
  63 #endif
  64
  65 Status UnpackAutomationExtension(const base::FilePath& temp_dir,
  66                                  base::FilePath* automation_extension) {
  67   std::string decoded_extension;
  68   if (!base::Base64Decode(kAutomationExtension, &decoded_extension))
  69     return Status(kUnknownError, "failed to base64decode automation extension");
  70
  71   base::FilePath extension_zip = temp_dir.AppendASCII("internal.zip");
  72   int size = static_cast<int>(decoded_extension.length());
  73   if (base::WriteFile(extension_zip, decoded_extension.c_str(), size)
  74       != size) {
  75     return Status(kUnknownError, "failed to write automation extension zip");
  76   }
  77
  78   base::FilePath extension_dir = temp_dir.AppendASCII("internal");
  79   if (!zip::Unzip(extension_zip, extension_dir))
  80     return Status(kUnknownError, "failed to unzip automation extension");
  81
  82   *automation_extension = extension_dir;
  83   return Status(kOk);
  84 }
  85
  86 Status PrepareCommandLine(int port,
  87                           const Capabilities& capabilities,
  88                           CommandLine* prepared_command,
  89                           base::ScopedTempDir* user_data_dir,
  90                           base::ScopedTempDir* extension_dir,
  91                           std::vector<std::string>* extension_bg_pages) {
  92   base::FilePath program = capabilities.binary;
  93   if (program.empty()) {
  94     if (!FindChrome(&program))
  95       return Status(kUnknownError, "cannot find Chrome binary");
  96   } else if (!base::PathExists(program)) {
  97     return Status(kUnknownError,
  98                   base::StringPrintf("no chrome binary at %" PRFilePath,
  99                                      program.value().c_str()));
 100   }
 101   CommandLine command(program);
 102   Switches switches;
 103
 104   for (size_t i = 0; i < arraysize(kCommonSwitches); ++i)
 105     switches.SetSwitch(kCommonSwitches[i]);
 106   switches.SetSwitch("disable-hang-monitor");
 107   switches.SetSwitch("disable-prompt-on-repost");
 108   switches.SetSwitch("disable-sync");
 109   switches.SetSwitch("no-first-run");
 110   switches.SetSwitch("disable-background-networking");
 111   switches.SetSwitch("disable-web-resources");
 112   switches.SetSwitch("safebrowsing-disable-auto-update");
 113   switches.SetSwitch("safebrowsing-disable-download-protection");
 114   switches.SetSwitch("disable-client-side-phishing-detection");
 115   switches.SetSwitch("disable-component-update");
 116   switches.SetSwitch("disable-default-apps");
 117   switches.SetSwitch("enable-logging");
 118   switches.SetSwitch("log-level", "0");
 119   switches.SetSwitch("password-store", "basic");
 120   switches.SetSwitch("use-mock-keychain");
 121   switches.SetSwitch("remote-debugging-port", base::IntToString(port));
 122   switches.SetSwitch("test-type", "webdriver");
 123
 124   for (std::set<std::string>::const_iterator iter =
 125            capabilities.exclude_switches.begin();
 126        iter != capabilities.exclude_switches.end();
 127        ++iter) {
 128     switches.RemoveSwitch(*iter);
 129   }
 130   switches.SetFromSwitches(capabilities.switches);
 131
 132   if (!switches.HasSwitch("user-data-dir")) {
 133     command.AppendArg("data:,");
 134     if (!user_data_dir->CreateUniqueTempDir())
 135       return Status(kUnknownError, "cannot create temp dir for user data dir");
 136     switches.SetSwitch("user-data-dir", user_data_dir->path().value());
 137     Status status = internal::PrepareUserDataDir(
 138         user_data_dir->path(), capabilities.prefs.get(),
 139         capabilities.local_state.get());
 140     if (status.IsError())
 141       return status;
 142   }
 143
 144   if (!extension_dir->CreateUniqueTempDir()) {
 145     return Status(kUnknownError,
 146                   "cannot create temp dir for unpacking extensions");
 147   }
 148   Status status = internal::ProcessExtensions(capabilities.extensions,
 149                                               extension_dir->path(),
 150                                               true,
 151                                               &switches,
 152                                               extension_bg_pages);
 153   if (status.IsError())
 154     return status;
 155   switches.AppendToCommandLine(&command);
 156   *prepared_command = command;
 157   return Status(kOk);
 158 }
 159
 160 Status WaitForDevToolsAndCheckVersion(
 161     const NetAddress& address,
 162     URLRequestContextGetter* context_getter,
 163     const SyncWebSocketFactory& socket_factory,
 164     const Capabilities* capabilities,
 165     scoped_ptr<DevToolsHttpClient>* user_client) {
 166   scoped_ptr<DeviceMetrics> device_metrics;
 167   if (capabilities && capabilities->device_metrics)
 168     device_metrics.reset(new DeviceMetrics(*capabilities->device_metrics));
 169
 170   scoped_ptr<DevToolsHttpClient> client(new DevToolsHttpClient(
 171       address, context_getter, socket_factory, device_metrics.Pass()));
 172   base::TimeTicks deadline =
 173       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(60);
 174   Status status = client->Init(deadline - base::TimeTicks::Now());
 175   if (status.IsError())
 176     return status;
 177   if (client->browser_info()->build_no < kMinimumSupportedChromeBuildNo) {
 178     return Status(kUnknownError, "Chrome version must be >= " +
 179         GetMinimumSupportedChromeVersion());
 180   }
 181
 182   while (base::TimeTicks::Now() < deadline) {
 183     WebViewsInfo views_info;
 184     client->GetWebViewsInfo(&views_info);
 185     for (size_t i = 0; i < views_info.GetSize(); ++i) {
 186       if (views_info.Get(i).type == WebViewInfo::kPage) {
 187         *user_client = client.Pass();
 188         return Status(kOk);
 189       }
 190     }
 191     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
 192   }
 193   return Status(kUnknownError, "unable to discover open pages");
 194 }
 195
 196 Status CreateBrowserwideDevToolsClientAndConnect(
 197     const NetAddress& address,
 198     const PerfLoggingPrefs& perf_logging_prefs,
 199     const SyncWebSocketFactory& socket_factory,
 200     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
 201     scoped_ptr<DevToolsClient>* browser_client) {
 202   scoped_ptr<DevToolsClient> client(new DevToolsClientImpl(
 203       socket_factory, base::StringPrintf("ws://%s/devtools/browser/",
 204                                          address.ToString().c_str()),
 205       DevToolsClientImpl::kBrowserwideDevToolsClientId));
 206   for (ScopedVector<DevToolsEventListener>::const_iterator it =
 207           devtools_event_listeners.begin();
 208       it != devtools_event_listeners.end();
 209       ++it) {
 210     // Only add listeners that subscribe to the browser-wide |DevToolsClient|.
 211     // Otherwise, listeners will think this client is associated with a webview,
 212     // and will send unrecognized commands to it.
 213     if ((*it)->subscribes_to_browser())
 214       client->AddListener(*it);
 215   }
 216   // Provide the client regardless of whether it connects, so that Chrome always
 217   // has a valid |devtools_websocket_client_|. If not connected, no listeners
 218   // will be notified, and client will just return kDisconnected errors if used.
 219   *browser_client = client.Pass();
 220   // To avoid unnecessary overhead, only connect if tracing is enabled, since
 221   // the browser-wide client is currently only used for tracing.
 222   if (!perf_logging_prefs.trace_categories.empty()) {
 223     Status status = (*browser_client)->ConnectIfNecessary();
 224     if (status.IsError())
 225       return status;
 226   }
 227   return Status(kOk);
 228 }
 229
 230 Status LaunchRemoteChromeSession(
 231     URLRequestContextGetter* context_getter,
 232     const SyncWebSocketFactory& socket_factory,
 233     const Capabilities& capabilities,
 234     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
 235     scoped_ptr<Chrome>* chrome) {
 236   Status status(kOk);
 237   scoped_ptr<DevToolsHttpClient> devtools_http_client;
 238   status = WaitForDevToolsAndCheckVersion(
 239       capabilities.debugger_address, context_getter, socket_factory,
 240       NULL, &devtools_http_client);
 241   if (status.IsError()) {
 242     return Status(kUnknownError, "cannot connect to chrome at " +
 243                       capabilities.debugger_address.ToString(),
 244                   status);
 245   }
 246
 247   scoped_ptr<DevToolsClient> devtools_websocket_client;
 248   status = CreateBrowserwideDevToolsClientAndConnect(
 249       capabilities.debugger_address, capabilities.perf_logging_prefs,
 250       socket_factory, devtools_event_listeners, &devtools_websocket_client);
 251   if (status.IsError()) {
 252     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
 253                  << status.message();
 254   }
 255
 256   chrome->reset(new ChromeRemoteImpl(devtools_http_client.Pass(),
 257                                      devtools_websocket_client.Pass(),
 258                                      devtools_event_listeners));
 259   return Status(kOk);
 260 }
 261
 262 Status LaunchDesktopChrome(
 263     URLRequestContextGetter* context_getter,
 264     int port,
 265     scoped_ptr<PortReservation> port_reservation,
 266     const SyncWebSocketFactory& socket_factory,
 267     const Capabilities& capabilities,
 268     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
 269     scoped_ptr<Chrome>* chrome) {
 270   CommandLine command(CommandLine::NO_PROGRAM);
 271   base::ScopedTempDir user_data_dir;
 272   base::ScopedTempDir extension_dir;
 273   std::vector<std::string> extension_bg_pages;
 274   Status status = PrepareCommandLine(port,
 275                                      capabilities,
 276                                      &command,
 277                                      &user_data_dir,
 278                                      &extension_dir,
 279                                      &extension_bg_pages);
 280   if (status.IsError())
 281     return status;
 282
 283   base::LaunchOptions options;
 284
 285 #if defined(OS_LINUX)
 286   // If minidump path is set in the capability, enable minidump for crashes.
 287   if (!capabilities.minidump_path.empty()) {
 288     VLOG(0) << "Minidump generation specified. Will save dumps to: "
 289             << capabilities.minidump_path;
 290
 291     options.environ["CHROME_HEADLESS"] = 1;
 292     options.environ["BREAKPAD_DUMP_LOCATION"] = capabilities.minidump_path;
 293
 294     if (!command.HasSwitch(kEnableCrashReport))
 295       command.AppendSwitch(kEnableCrashReport);
 296   }
 297
 298   // We need to allow new privileges so that chrome's setuid sandbox can run.
 299   options.allow_new_privs = true;
 300 #endif
 301
 302 #if !defined(OS_WIN)
 303   if (!capabilities.log_path.empty())
 304     options.environ["CHROME_LOG_FILE"] = capabilities.log_path;
 305   if (capabilities.detach)
 306     options.new_process_group = true;
 307 #endif
 308
 309 #if defined(OS_POSIX)
 310   base::FileHandleMappingVector no_stderr;
 311   base::ScopedFD devnull;
 312   if (!CommandLine::ForCurrentProcess()->HasSwitch("verbose")) {
 313     // Redirect stderr to /dev/null, so that Chrome log spew doesn't confuse
 314     // users.
 315     devnull.reset(HANDLE_EINTR(open("/dev/null", O_WRONLY)));
 316     if (!devnull.is_valid())
 317       return Status(kUnknownError, "couldn't open /dev/null");
 318     no_stderr.push_back(std::make_pair(devnull.get(), STDERR_FILENO));
 319     options.fds_to_remap = &no_stderr;
 320   }
 321 #endif
 322
 323 #if defined(OS_WIN)
 324   std::string command_string = base::WideToUTF8(command.GetCommandLineString());
 325 #else
 326   std::string command_string = command.GetCommandLineString();
 327 #endif
 328   VLOG(0) << "Launching chrome: " << command_string;
 329   base::ProcessHandle process;
 330   if (!base::LaunchProcess(command, options, &process))
 331     return Status(kUnknownError, "chrome failed to start");
 332
 333   scoped_ptr<DevToolsHttpClient> devtools_http_client;
 334   status = WaitForDevToolsAndCheckVersion(
 335       NetAddress(port), context_getter, socket_factory, &capabilities,
 336       &devtools_http_client);
 337
 338   if (status.IsError()) {
 339     int exit_code;
 340     base::TerminationStatus chrome_status =
 341         base::GetTerminationStatus(process, &exit_code);
 342     if (chrome_status != base::TERMINATION_STATUS_STILL_RUNNING) {
 343       std::string termination_reason;
 344       switch (chrome_status) {
 345         case base::TERMINATION_STATUS_NORMAL_TERMINATION:
 346           termination_reason = "exited normally";
 347           break;
 348         case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
 349           termination_reason = "exited abnormally";
 350           break;
 351         case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
 352           termination_reason = "was killed";
 353           break;
 354         case base::TERMINATION_STATUS_PROCESS_CRASHED:
 355           termination_reason = "crashed";
 356           break;
 357         default:
 358           termination_reason = "unknown";
 359           break;
 360       }
 361       return Status(kUnknownError,
 362                     "Chrome failed to start: " + termination_reason);
 363     }
 364     if (!base::KillProcess(process, 0, true)) {
 365       int exit_code;
 366       if (base::GetTerminationStatus(process, &exit_code) ==
 367           base::TERMINATION_STATUS_STILL_RUNNING)
 368         return Status(kUnknownError, "cannot kill Chrome", status);
 369     }
 370     return status;
 371   }
 372
 373   scoped_ptr<DevToolsClient> devtools_websocket_client;
 374   status = CreateBrowserwideDevToolsClientAndConnect(
 375       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
 376       devtools_event_listeners, &devtools_websocket_client);
 377   if (status.IsError()) {
 378     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
 379                  << status.message();
 380   }
 381
 382   scoped_ptr<ChromeDesktopImpl> chrome_desktop(
 383       new ChromeDesktopImpl(devtools_http_client.Pass(),
 384                             devtools_websocket_client.Pass(),
 385                             devtools_event_listeners,
 386                             port_reservation.Pass(),
 387                             process,
 388                             command,
 389                             &user_data_dir,
 390                             &extension_dir));
 391   for (size_t i = 0; i < extension_bg_pages.size(); ++i) {
 392     VLOG(0) << "Waiting for extension bg page load: " << extension_bg_pages[i];
 393     scoped_ptr<WebView> web_view;
 394     Status status = chrome_desktop->WaitForPageToLoad(
 395         extension_bg_pages[i], base::TimeDelta::FromSeconds(10), &web_view);
 396     if (status.IsError()) {
 397       return Status(kUnknownError,
 398                     "failed to wait for extension background page to load: " +
 399                         extension_bg_pages[i],
 400                     status);
 401     }
 402   }
 403   *chrome = chrome_desktop.Pass();
 404   return Status(kOk);
 405 }
 406
 407 Status LaunchAndroidChrome(
 408     URLRequestContextGetter* context_getter,
 409     int port,
 410     scoped_ptr<PortReservation> port_reservation,
 411     const SyncWebSocketFactory& socket_factory,
 412     const Capabilities& capabilities,
 413     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
 414     DeviceManager* device_manager,
 415     scoped_ptr<Chrome>* chrome) {
 416   Status status(kOk);
 417   scoped_ptr<Device> device;
 418   if (capabilities.android_device_serial.empty()) {
 419     status = device_manager->AcquireDevice(&device);
 420   } else {
 421     status = device_manager->AcquireSpecificDevice(
 422         capabilities.android_device_serial, &device);
 423   }
 424   if (status.IsError())
 425     return status;
 426
 427   Switches switches(capabilities.switches);
 428   for (size_t i = 0; i < arraysize(kCommonSwitches); ++i)
 429     switches.SetSwitch(kCommonSwitches[i]);
 430   switches.SetSwitch("disable-fre");
 431   switches.SetSwitch("enable-remote-debugging");
 432   status = device->SetUp(capabilities.android_package,
 433                          capabilities.android_activity,
 434                          capabilities.android_process,
 435                          switches.ToString(),
 436                          capabilities.android_use_running_app,
 437                          port);
 438   if (status.IsError()) {
 439     device->TearDown();
 440     return status;
 441   }
 442
 443   scoped_ptr<DevToolsHttpClient> devtools_http_client;
 444   status = WaitForDevToolsAndCheckVersion(NetAddress(port),
 445                                           context_getter,
 446                                           socket_factory,
 447                                           &capabilities,
 448                                           &devtools_http_client);
 449   if (status.IsError()) {
 450     device->TearDown();
 451     return status;
 452   }
 453
 454   scoped_ptr<DevToolsClient> devtools_websocket_client;
 455   status = CreateBrowserwideDevToolsClientAndConnect(
 456       NetAddress(port), capabilities.perf_logging_prefs, socket_factory,
 457       devtools_event_listeners, &devtools_websocket_client);
 458   if (status.IsError()) {
 459     LOG(WARNING) << "Browser-wide DevTools client failed to connect: "
 460                  << status.message();
 461   }
 462
 463   chrome->reset(new ChromeAndroidImpl(devtools_http_client.Pass(),
 464                                       devtools_websocket_client.Pass(),
 465                                       devtools_event_listeners,
 466                                       port_reservation.Pass(),
 467                                       device.Pass()));
 468   return Status(kOk);
 469 }
 470
 471 }  // namespace
 472
 473 Status LaunchChrome(
 474     URLRequestContextGetter* context_getter,
 475     const SyncWebSocketFactory& socket_factory,
 476     DeviceManager* device_manager,
 477     PortServer* port_server,
 478     PortManager* port_manager,
 479     const Capabilities& capabilities,
 480     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
 481     scoped_ptr<Chrome>* chrome) {
 482   if (capabilities.IsRemoteBrowser()) {
 483     return LaunchRemoteChromeSession(
 484         context_getter, socket_factory,
 485         capabilities, devtools_event_listeners, chrome);
 486   }
 487
 488   int port = 0;
 489   scoped_ptr<PortReservation> port_reservation;
 490   Status port_status(kOk);
 491
 492   if (capabilities.IsAndroid()) {
 493     port_status = port_manager->ReservePortFromPool(&port, &port_reservation);
 494     if (port_status.IsError())
 495       return Status(kUnknownError, "cannot reserve port for Chrome",
 496                     port_status);
 497     return LaunchAndroidChrome(context_getter,
 498                                port,
 499                                port_reservation.Pass(),
 500                                socket_factory,
 501                                capabilities,
 502                                devtools_event_listeners,
 503                                device_manager,
 504                                chrome);
 505   } else {
 506     if (port_server)
 507       port_status = port_server->ReservePort(&port, &port_reservation);
 508     else
 509       port_status = port_manager->ReservePort(&port, &port_reservation);
 510     if (port_status.IsError())
 511       return Status(kUnknownError, "cannot reserve port for Chrome",
 512                     port_status);
 513     return LaunchDesktopChrome(context_getter,
 514                                port,
 515                                port_reservation.Pass(),
 516                                socket_factory,
 517                                capabilities,
 518                                devtools_event_listeners,
 519                                chrome);
 520   }
 521 }
 522
 523 namespace internal {
 524
 525 void ConvertHexadecimalToIDAlphabet(std::string* id) {
 526   for (size_t i = 0; i < id->size(); ++i) {
 527     int val;
 528     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
 529                                                id->begin() + i + 1),
 530                              &val)) {
 531       (*id)[i] = val + 'a';
 532     } else {
 533       (*id)[i] = 'a';
 534     }
 535   }
 536 }
 537
 538 std::string GenerateExtensionId(const std::string& input) {
 539   uint8 hash[16];
 540   crypto::SHA256HashString(input, hash, sizeof(hash));
 541   std::string output =
 542       base::StringToLowerASCII(base::HexEncode(hash, sizeof(hash)));
 543   ConvertHexadecimalToIDAlphabet(&output);
 544   return output;
 545 }
 546
 547 Status GetExtensionBackgroundPage(const base::DictionaryValue* manifest,
 548                                   const std::string& id,
 549                                   std::string* bg_page) {
 550   std::string bg_page_name;
 551   bool persistent = true;
 552   manifest->GetBoolean("background.persistent", &persistent);
 553   const base::Value* unused_value;
 554   if (manifest->Get("background.scripts", &unused_value))
 555     bg_page_name = "_generated_background_page.html";
 556   manifest->GetString("background.page", &bg_page_name);
 557   manifest->GetString("background_page", &bg_page_name);
 558   if (bg_page_name.empty() || !persistent)
 559     return Status(kOk);
 560   *bg_page = "chrome-extension://" + id + "/" + bg_page_name;
 561   return Status(kOk);
 562 }
 563
 564 Status ProcessExtension(const std::string& extension,
 565                         const base::FilePath& temp_dir,
 566                         base::FilePath* path,
 567                         std::string* bg_page) {
 568   // Decodes extension string.
 569   // Some WebDriver client base64 encoders follow RFC 1521, which require that
 570   // 'encoded lines be no more than 76 characters long'. Just remove any
 571   // newlines.
 572   std::string extension_base64;
 573   base::RemoveChars(extension, "\n", &extension_base64);
 574   std::string decoded_extension;
 575   if (!base::Base64Decode(extension_base64, &decoded_extension))
 576     return Status(kUnknownError, "cannot base64 decode");
 577
 578   // If the file is a crx file, extract the extension's ID from its public key.
 579   // Otherwise generate a random public key and use its derived extension ID.
 580   std::string public_key;
 581   std::string magic_header = decoded_extension.substr(0, 4);
 582   if (magic_header.size() != 4)
 583     return Status(kUnknownError, "cannot extract magic number");
 584
 585   const bool is_crx_file = magic_header == "Cr24";
 586
 587   if (is_crx_file) {
 588     // Assume a CRX v2 file - see https://developer.chrome.com/extensions/crx.
 589     std::string key_len_str = decoded_extension.substr(8, 4);
 590     if (key_len_str.size() != 4)
 591       return Status(kUnknownError, "cannot extract public key length");
 592     uint32 key_len = *reinterpret_cast<const uint32*>(key_len_str.c_str());
 593     public_key = decoded_extension.substr(16, key_len);
 594     if (key_len != public_key.size())
 595       return Status(kUnknownError, "invalid public key length");
 596   } else {
 597     // Not a CRX file. Generate RSA keypair to get a valid extension id.
 598     scoped_ptr<crypto::RSAPrivateKey> key_pair(
 599         crypto::RSAPrivateKey::Create(2048));
 600     if (!key_pair)
 601       return Status(kUnknownError, "cannot generate RSA key pair");
 602     std::vector<uint8> public_key_vector;
 603     if (!key_pair->ExportPublicKey(&public_key_vector))
 604       return Status(kUnknownError, "cannot extract public key");
 605     public_key =
 606         std::string(reinterpret_cast<char*>(&public_key_vector.front()),
 607                     public_key_vector.size());
 608   }
 609   std::string public_key_base64;
 610   base::Base64Encode(public_key, &public_key_base64);
 611   std::string id = GenerateExtensionId(public_key);
 612
 613   // Unzip the crx file.
 614   base::ScopedTempDir temp_crx_dir;
 615   if (!temp_crx_dir.CreateUniqueTempDir())
 616     return Status(kUnknownError, "cannot create temp dir");
 617   base::FilePath extension_crx = temp_crx_dir.path().AppendASCII("temp.crx");
 618   int size = static_cast<int>(decoded_extension.length());
 619   if (base::WriteFile(extension_crx, decoded_extension.c_str(), size) !=
 620       size) {
 621     return Status(kUnknownError, "cannot write file");
 622   }
 623   base::FilePath extension_dir = temp_dir.AppendASCII("extension_" + id);
 624   if (!zip::Unzip(extension_crx, extension_dir))
 625     return Status(kUnknownError, "cannot unzip");
 626
 627   // Parse the manifest and set the 'key' if not already present.
 628   base::FilePath manifest_path(extension_dir.AppendASCII("manifest.json"));
 629   std::string manifest_data;
 630   if (!base::ReadFileToString(manifest_path, &manifest_data))
 631     return Status(kUnknownError, "cannot read manifest");
 632   scoped_ptr<base::Value> manifest_value(base::JSONReader::Read(manifest_data));
 633   base::DictionaryValue* manifest;
 634   if (!manifest_value || !manifest_value->GetAsDictionary(&manifest))
 635     return Status(kUnknownError, "invalid manifest");
 636
 637   std::string manifest_key_base64;
 638   if (manifest->GetString("key", &manifest_key_base64)) {
 639     // If there is a key in both the header and the manifest, use the key in the
 640     // manifest. This allows chromedriver users users who generate dummy crxs
 641     // to set the manifest key and have a consistent ID.
 642     std::string manifest_key;
 643     if (!base::Base64Decode(manifest_key_base64, &manifest_key))
 644       return Status(kUnknownError, "'key' in manifest is not base64 encoded");
 645     std::string manifest_id = GenerateExtensionId(manifest_key);
 646     if (id != manifest_id) {
 647       if (is_crx_file) {
 648         LOG(WARNING)
 649             << "Public key in crx header is different from key in manifest"
 650             << std::endl << "key from header:   " << public_key_base64
 651             << std::endl << "key from manifest: " << manifest_key_base64
 652             << std::endl << "generated extension id from header key:   " << id
 653             << std::endl << "generated extension id from manifest key: "
 654             << manifest_id;
 655       }
 656       id = manifest_id;
 657     }
 658   } else {
 659     manifest->SetString("key", public_key_base64);
 660     base::JSONWriter::Write(manifest, &manifest_data);
 661     if (base::WriteFile(
 662             manifest_path, manifest_data.c_str(), manifest_data.size()) !=
 663         static_cast<int>(manifest_data.size())) {
 664       return Status(kUnknownError, "cannot add 'key' to manifest");
 665     }
 666   }
 667
 668   // Get extension's background page URL, if there is one.
 669   std::string bg_page_tmp;
 670   Status status = GetExtensionBackgroundPage(manifest, id, &bg_page_tmp);
 671   if (status.IsError())
 672     return status;
 673
 674   *path = extension_dir;
 675   if (bg_page_tmp.size())
 676     *bg_page = bg_page_tmp;
 677   return Status(kOk);
 678 }
 679
 680 void UpdateExtensionSwitch(Switches* switches,
 681                            const char name[],
 682                            const base::FilePath::StringType& extension) {
 683   base::FilePath::StringType value = switches->GetSwitchValueNative(name);
 684   if (value.length())
 685     value += FILE_PATH_LITERAL(",");
 686   value += extension;
 687   switches->SetSwitch(name, value);
 688 }
 689
 690 Status ProcessExtensions(const std::vector<std::string>& extensions,
 691                          const base::FilePath& temp_dir,
 692                          bool include_automation_extension,
 693                          Switches* switches,
 694                          std::vector<std::string>* bg_pages) {
 695   std::vector<std::string> bg_pages_tmp;
 696   std::vector<base::FilePath::StringType> extension_paths;
 697   for (size_t i = 0; i < extensions.size(); ++i) {
 698     base::FilePath path;
 699     std::string bg_page;
 700     Status status = ProcessExtension(extensions[i], temp_dir, &path, &bg_page);
 701     if (status.IsError()) {
 702       return Status(
 703           kUnknownError,
 704           base::StringPrintf("cannot process extension #%" PRIuS, i + 1),
 705           status);
 706     }
 707     extension_paths.push_back(path.value());
 708     if (bg_page.length())
 709       bg_pages_tmp.push_back(bg_page);
 710   }
 711
 712   if (include_automation_extension) {
 713     base::FilePath automation_extension;
 714     Status status = UnpackAutomationExtension(temp_dir, &automation_extension);
 715     if (status.IsError())
 716       return status;
 717     if (switches->HasSwitch("disable-extensions")) {
 718       UpdateExtensionSwitch(switches, "load-component-extension",
 719                             automation_extension.value());
 720     } else {
 721       extension_paths.push_back(automation_extension.value());
 722     }
 723   }
 724
 725   if (extension_paths.size()) {
 726     base::FilePath::StringType extension_paths_value = JoinString(
 727         extension_paths, FILE_PATH_LITERAL(','));
 728     UpdateExtensionSwitch(switches, "load-extension", extension_paths_value);
 729   }
 730   bg_pages->swap(bg_pages_tmp);
 731   return Status(kOk);
 732 }
 733
 734 Status WritePrefsFile(
 735     const std::string& template_string,
 736     const base::DictionaryValue* custom_prefs,
 737     const base::FilePath& path) {
 738   int code;
 739   std::string error_msg;
 740   scoped_ptr<base::Value> template_value(base::JSONReader::ReadAndReturnError(
 741           template_string, 0, &code, &error_msg));
 742   base::DictionaryValue* prefs;
 743   if (!template_value || !template_value->GetAsDictionary(&prefs)) {
 744     return Status(kUnknownError,
 745                   "cannot parse internal JSON template: " + error_msg);
 746   }
 747
 748   if (custom_prefs) {
 749     for (base::DictionaryValue::Iterator it(*custom_prefs); !it.IsAtEnd();
 750          it.Advance()) {
 751       prefs->Set(it.key(), it.value().DeepCopy());
 752     }
 753   }
 754
 755   std::string prefs_str;
 756   base::JSONWriter::Write(prefs, &prefs_str);
 757   VLOG(0) << "Populating " << path.BaseName().value()
 758           << " file: " << PrettyPrintValue(*prefs);
 759   if (static_cast<int>(prefs_str.length()) != base::WriteFile(
 760           path, prefs_str.c_str(), prefs_str.length())) {
 761     return Status(kUnknownError, "failed to write prefs file");
 762   }
 763   return Status(kOk);
 764 }
 765
 766 Status PrepareUserDataDir(
 767     const base::FilePath& user_data_dir,
 768     const base::DictionaryValue* custom_prefs,
 769     const base::DictionaryValue* custom_local_state) {
 770   base::FilePath default_dir =
 771       user_data_dir.AppendASCII(chrome::kInitialProfile);
 772   if (!base::CreateDirectory(default_dir))
 773     return Status(kUnknownError, "cannot create default profile directory");
 774
 775   Status status =
 776       WritePrefsFile(kPreferences,
 777                      custom_prefs,
 778                      default_dir.Append(chrome::kPreferencesFilename));
 779   if (status.IsError())
 780     return status;
 781
 782   status = WritePrefsFile(kLocalState,
 783                           custom_local_state,
 784                           user_data_dir.Append(chrome::kLocalStateFilename));
 785   if (status.IsError())
 786     return status;
 787
 788   // Write empty "First Run" file, otherwise Chrome will wipe the default
 789   // profile that was written.
 790   if (base::WriteFile(
 791           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
 792     return Status(kUnknownError, "failed to write first run file");
 793   }
 794   return Status(kOk);
 795 }
 796
 797 }  // namespace internal