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

chrome/test/chromedriver/session_commands.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/session_commands.h"
 
 #include <list>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 184 matching lines @@
   // |session| will own the |CommandListener|s.
   session->command_listeners.swap(command_listeners);
 
   status = LaunchChrome(bound_params.context_getter.get(),
                         bound_params.socket_factory,
                         bound_params.device_manager,
                         bound_params.port_server,
                         bound_params.port_manager,
                         capabilities,
                         &devtools_event_listeners,
-                        &session->chrome);
+                        &session->chrome,
+                        session->w3c_compliant);
   if (status.IsError())
     return status;
 
   session->chrome->set_page_load_strategy(capabilities.page_load_strategy);
 
   std::list<std::string> web_view_ids;
-  status = session->chrome->GetWebViewIds(&web_view_ids);
+  status = session->chrome->GetWebViewIds(&web_view_ids,
+                                          session->w3c_compliant);
   if (status.IsError() || web_view_ids.empty()) {
     return status.IsError() ? status :
         Status(kUnknownError, "unable to discover open window in chrome");
   }
 
   session->window = web_view_ids.front();
   session->detach = capabilities.detach;
   session->force_devtools_screenshot = capabilities.force_devtools_screenshot;
   session->capabilities = CreateCapabilities(session->chrome.get());
   value->reset(session->capabilities->DeepCopy());
@@ skipping 52 matching lines @@
   std::string id;
   if (!params.GetString("id", &id))
     return Status(kUnknownError, "'id' must be a string");
 
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsError())
     return status;
 
   AutomationExtension* extension = NULL;
-  status = desktop->GetAutomationExtension(&extension);
+  status = desktop->GetAutomationExtension(&extension, session->w3c_compliant);
   if (status.IsError())
     return status;
 
   return extension->LaunchApp(id);
 }
 
 Status ExecuteClose(Session* session,
                     const base::DictionaryValue& params,
                     std::unique_ptr<base::Value>* value) {
   std::list<std::string> web_view_ids;
-  Status status = session->chrome->GetWebViewIds(&web_view_ids);
+  Status status = session->chrome->GetWebViewIds(&web_view_ids,
+                                                 session->w3c_compliant);
   if (status.IsError())
     return status;
   bool is_last_web_view = web_view_ids.size() == 1u;
   web_view_ids.clear();
 
   WebView* web_view = NULL;
   status = session->GetTargetWindow(&web_view);
   if (status.IsError())
     return status;
 
   status = session->chrome->CloseWebView(web_view->GetId());
   if (status.IsError())
     return status;
 
-  status = session->chrome->GetWebViewIds(&web_view_ids);
+  status = session->chrome->GetWebViewIds(&web_view_ids,
+                                          session->w3c_compliant);
   if ((status.code() == kChromeNotReachable && is_last_web_view) ||
       (status.IsOk() && web_view_ids.empty())) {
     // If no window is open, close is the equivalent of calling "quit".
     session->quit = true;
     return session->chrome->Quit();
   }
 
   return status;
 }
 
 Status ExecuteGetWindowHandles(Session* session,
                                const base::DictionaryValue& params,
                                std::unique_ptr<base::Value>* value) {
   std::list<std::string> web_view_ids;
-  Status status = session->chrome->GetWebViewIds(&web_view_ids);
+  Status status = session->chrome->GetWebViewIds(&web_view_ids,
+                                                 session->w3c_compliant);
   if (status.IsError())
     return status;
   std::unique_ptr<base::ListValue> window_ids(new base::ListValue());
   for (std::list<std::string>::const_iterator it = web_view_ids.begin();
        it != web_view_ids.end(); ++it) {
     window_ids->AppendString(WebViewIdToWindowHandle(*it));
   }
   value->reset(window_ids.release());
   return Status(kOk);
 }
 
 Status ExecuteSwitchToWindow(Session* session,
                              const base::DictionaryValue& params,
                              std::unique_ptr<base::Value>* value) {
   std::string name;
   if (!params.GetString("name", &name))
     return Status(kUnknownError, "'name' must be a string");
 
   std::list<std::string> web_view_ids;
-  Status status = session->chrome->GetWebViewIds(&web_view_ids);
+  Status status = session->chrome->GetWebViewIds(&web_view_ids,
+                                                 session->w3c_compliant);
   if (status.IsError())
     return status;
 
   std::string web_view_id;
   bool found = false;
   if (WindowHandleToWebViewId(name, &web_view_id)) {
     // Check if any web_view matches |web_view_id|.
     for (std::list<std::string>::const_iterator it = web_view_ids.begin();
          it != web_view_ids.end(); ++it) {
       if (*it == web_view_id) {
@@ skipping 240 matching lines @@
     network_conditions->offline = true;
   }
 
   session->overridden_network_conditions.reset(
       network_conditions.release());
 
   // Applies overridden network connection to all WebViews of the session
   // to ensure that network emulation is applied on a per-session basis
   // rather than the just to the current WebView.
   std::list<std::string> web_view_ids;
-  status = session->chrome->GetWebViewIds(&web_view_ids);
+  status = session->chrome->GetWebViewIds(&web_view_ids,
+                                          session->w3c_compliant);
   if (status.IsError())
     return status;
 
   for (std::string web_view_id : web_view_ids) {
     WebView* web_view;
     status = session->chrome->GetWebViewById(web_view_id, &web_view);
     if (status.IsError())
       return status;
     web_view->OverrideNetworkConditions(
       *session->overridden_network_conditions);
   }
   return Status(kOk);
 }
 
 Status ExecuteGetWindowPosition(Session* session,
                                 const base::DictionaryValue& params,
                                 std::unique_ptr<base::Value>* value) {
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsError())
     return status;
 
   AutomationExtension* extension = NULL;
-  status = desktop->GetAutomationExtension(&extension);
+  status = desktop->GetAutomationExtension(&extension, session->w3c_compliant);
   if (status.IsError())
     return status;
 
   int x, y;
   status = extension->GetWindowPosition(&x, &y);
   if (status.IsError())
     return status;
 
   base::DictionaryValue position;
   position.SetInteger("x", x);
   position.SetInteger("y", y);
   value->reset(position.DeepCopy());
   return Status(kOk);
 }
 
 Status ExecuteSetWindowPosition(Session* session,
                                 const base::DictionaryValue& params,
                                 std::unique_ptr<base::Value>* value) {
   double x = 0;
   double y = 0;
   if (!params.GetDouble("x", &x) || !params.GetDouble("y", &y))
     return Status(kUnknownError, "missing or invalid 'x' or 'y'");
 
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsError())
     return status;
 
   AutomationExtension* extension = NULL;
-  status = desktop->GetAutomationExtension(&extension);
+  status = desktop->GetAutomationExtension(&extension, session->w3c_compliant);
   if (status.IsError())
     return status;
 
   return extension->SetWindowPosition(static_cast<int>(x), static_cast<int>(y));
 }
 
 Status ExecuteGetWindowSize(Session* session,
                             const base::DictionaryValue& params,
                             std::unique_ptr<base::Value>* value) {
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsError())
     return status;
 
   AutomationExtension* extension = NULL;
-  status = desktop->GetAutomationExtension(&extension);
+  status = desktop->GetAutomationExtension(&extension, session->w3c_compliant);
   if (status.IsError())
     return status;
 
   int width, height;
   status = extension->GetWindowSize(&width, &height);
   if (status.IsError())
     return status;
 
   base::DictionaryValue size;
   size.SetInteger("width", width);
@@ skipping 10 matching lines @@
   if (!params.GetDouble("width", &width) ||
       !params.GetDouble("height", &height))
     return Status(kUnknownError, "missing or invalid 'width' or 'height'");
 
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsError())
     return status;
 
   AutomationExtension* extension = NULL;
-  status = desktop->GetAutomationExtension(&extension);
+  status = desktop->GetAutomationExtension(&extension, session->w3c_compliant);
   if (status.IsError())
     return status;
 
   return extension->SetWindowSize(
       static_cast<int>(width), static_cast<int>(height));
 }
 
 Status ExecuteMaximizeWindow(Session* session,
                              const base::DictionaryValue& params,
                              std::unique_ptr<base::Value>* value) {
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsError())
     return status;
 
   AutomationExtension* extension = NULL;
-  status = desktop->GetAutomationExtension(&extension);
+  status = desktop->GetAutomationExtension(&extension, session->w3c_compliant);
   if (status.IsError())
     return status;
 
   return extension->MaximizeWindow();
 }
 
 Status ExecuteGetAvailableLogTypes(Session* session,
                                    const base::DictionaryValue& params,
                                    std::unique_ptr<base::Value>* value) {
   std::unique_ptr<base::ListValue> types(new base::ListValue());
@@ skipping 89 matching lines @@
   session->auto_reporting_enabled = enabled;
   return Status(kOk);
 }
 
 
 Status ExecuteUnimplementedCommand(Session* session,
                                    const base::DictionaryValue& params,
                                    std::unique_ptr<base::Value>* value) {
   return Status(kUnknownCommand);
 }