[chromedriver] Added option to make element references W3C compliant.

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 300 matching lines @@
   return Status(kOk);
 }
 
 Status LaunchDesktopChrome(
     URLRequestContextGetter* context_getter,
     uint16_t port,
     std::unique_ptr<PortReservation> port_reservation,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>* devtools_event_listeners,
-    std::unique_ptr<Chrome>* chrome) {
+    std::unique_ptr<Chrome>* chrome,
+    bool w3c_compliant) {
   base::CommandLine command(base::CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
   std::vector<std::string> extension_bg_pages;
   Status status = PrepareCommandLine(port,
                                      capabilities,
                                      &command,
                                      &user_data_dir,
                                      &extension_dir,
                                      &extension_bg_pages);
@@ skipping 111 matching lines @@
 
   std::unique_ptr<ChromeDesktopImpl> chrome_desktop(new ChromeDesktopImpl(
       std::move(devtools_http_client), std::move(devtools_websocket_client),
       *devtools_event_listeners, std::move(port_reservation),
       std::move(process), command, &user_data_dir, &extension_dir,
       capabilities.network_emulation_enabled));
   for (size_t i = 0; i < extension_bg_pages.size(); ++i) {
     VLOG(0) << "Waiting for extension bg page load: " << extension_bg_pages[i];
     std::unique_ptr<WebView> web_view;
     Status status = chrome_desktop->WaitForPageToLoad(
-        extension_bg_pages[i], base::TimeDelta::FromSeconds(10), &web_view);
+        extension_bg_pages[i], base::TimeDelta::FromSeconds(10),
+        &web_view, w3c_compliant);
     if (status.IsError()) {
       return Status(kUnknownError,
                     "failed to wait for extension background page to load: " +
                         extension_bg_pages[i],
                     status);
     }
   }
   *chrome = std::move(chrome_desktop);
   return Status(kOk);
 }
@@ skipping 66 matching lines @@
 }  // namespace
 
 Status LaunchChrome(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
     DeviceManager* device_manager,
     PortServer* port_server,
     PortManager* port_manager,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>* devtools_event_listeners,
-    std::unique_ptr<Chrome>* chrome) {
+    std::unique_ptr<Chrome>* chrome,
+    bool w3c_compliant) {
   if (capabilities.IsRemoteBrowser()) {
     return LaunchRemoteChromeSession(
         context_getter, socket_factory,
         capabilities, devtools_event_listeners, chrome);
   }
 
   uint16_t port = 0;
   std::unique_ptr<PortReservation> port_reservation;
   Status port_status(kOk);
 
@@ skipping 11 matching lines @@
   } else {
     if (port_server)
       port_status = port_server->ReservePort(&port, &port_reservation);
     else
       port_status = port_manager->ReservePort(&port, &port_reservation);
     if (port_status.IsError())
       return Status(kUnknownError, "cannot reserve port for Chrome",
                     port_status);
     return LaunchDesktopChrome(context_getter, port,
                                std::move(port_reservation), socket_factory,
-                               capabilities, devtools_event_listeners, chrome);
+                               capabilities, devtools_event_listeners, chrome,
+                               w3c_compliant);
   }
 }
 
 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 285 matching lines @@
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (base::WriteFile(
           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal