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

chrome/test/chromedriver/chrome/web_view_impl.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/web_view_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 108 matching lines @@
       return "";
   }
 }
 
 }  // namespace
 
 WebViewImpl::WebViewImpl(const std::string& id,
                          const BrowserInfo* browser_info,
                          std::unique_ptr<DevToolsClient> client,
                          const DeviceMetrics* device_metrics,
-                         std::string page_load_strategy)
+                         std::string page_load_strategy,
+                         const bool w3c_compliant)

[samuong, 2016/08/11 18:13:20]

nit: move the |w3c_compliant| parameter up to the second parameter

[roisinmcl, 2016/08/13 01:47:26]

Done.

     : id_(id),
+      w3c_compliant_(w3c_compliant),
       browser_info_(browser_info),
       dom_tracker_(new DomTracker(client.get())),
       frame_tracker_(new FrameTracker(client.get())),
       dialog_manager_(new JavaScriptDialogManager(client.get())),
       navigation_tracker_(PageLoadStrategy::Create(
           page_load_strategy, client.get(),
           browser_info, dialog_manager_.get())),
       mobile_emulation_override_manager_(
           new MobileEmulationOverrideManager(client.get(), device_metrics)),
       geolocation_override_manager_(
@@ skipping 124 matching lines @@
   return internal::EvaluateScriptAndGetValue(
       client_.get(), context_id, expression, result);
 }
 
 Status WebViewImpl::CallFunction(const std::string& frame,
                                  const std::string& function,
                                  const base::ListValue& args,
                                  std::unique_ptr<base::Value>* result) {
   std::string json;
   base::JSONWriter::Write(args, &json);
+  std::string w3c = w3c_compliant_ ? "true" : "false";
   // TODO(zachconrad): Second null should be array of shadow host ids.
   std::string expression = base::StringPrintf(
-      "(%s).apply(null, [null, %s, %s])",
+      "(%s).apply(null, [null, %s, %s, %s])",
       kCallFunctionScript,
       function.c_str(),
-      json.c_str());
+      json.c_str(),
+      w3c.c_str());
   std::unique_ptr<base::Value> temp_result;
   Status status = EvaluateScript(frame, expression, &temp_result);
   if (status.IsError())
       return status;
   return internal::ParseCallFunctionResult(*temp_result, result);
 }
 
 Status WebViewImpl::CallAsyncFunction(const std::string& frame,
                                       const std::string& function,
                                       const base::ListValue& args,
@@ skipping 18 matching lines @@
                                        const base::ListValue& args,
                                        std::string* out_frame) {
   int context_id;
   Status status = GetContextIdForFrame(frame_tracker_.get(), frame,
                                        &context_id);
   if (status.IsError())
     return status;
   bool found_node;
   int node_id;
   status = internal::GetNodeIdFromFunction(
-      client_.get(), context_id, function, args, &found_node, &node_id);
+      client_.get(), context_id, function, args,
+      &found_node, &node_id, w3c_compliant_);
   if (status.IsError())
     return status;
   if (!found_node)
     return Status(kNoSuchFrame);
   return dom_tracker_->GetFrameIdForNode(node_id, out_frame);
 }
 
 Status WebViewImpl::DispatchMouseEvents(const std::list<MouseEvent>& events,
                                         const std::string& frame) {
   double page_scale_factor = 1.0;
@@ skipping 181 matching lines @@
   Status status = GetContextIdForFrame(frame_tracker_.get(), frame,
                                        &context_id);
   if (status.IsError())
     return status;
   base::ListValue args;
   args.Append(element.DeepCopy());
   bool found_node;
   int node_id;
   status = internal::GetNodeIdFromFunction(
       client_.get(), context_id, "function(element) { return element; }",
-      args, &found_node, &node_id);
+      args, &found_node, &node_id, w3c_compliant_);
   if (status.IsError())
     return status;
   if (!found_node)
     return Status(kUnknownError, "no node ID for file input");
   base::DictionaryValue params;
   params.SetInteger("nodeId", node_id);
   params.Set("files", file_list.DeepCopy());
   return client_->SendCommand("DOM.setFileInputFiles", params);
 }
 
@@ skipping 286 matching lines @@
   }
   result->reset(unscoped_value->DeepCopy());
   return Status(kOk);
 }
 
 Status GetNodeIdFromFunction(DevToolsClient* client,
                              int context_id,
                              const std::string& function,
                              const base::ListValue& args,
                              bool* found_node,
-                             int* node_id) {
+                             int* node_id,
+                             bool w3c_compliant) {
   std::string json;
   base::JSONWriter::Write(args, &json);
+  std::string w3c = w3c_compliant ? "true" : "false";
   // TODO(zachconrad): Second null should be array of shadow host ids.
   std::string expression = base::StringPrintf(
-      "(%s).apply(null, [null, %s, %s, true])",
+      "(%s).apply(null, [null, %s, %s, %s, true])",
       kCallFunctionScript,
       function.c_str(),
-      json.c_str());
+      json.c_str(),
+      w3c.c_str());
 
   bool got_object;
   std::string element_id;
   Status status = internal::EvaluateScriptAndGetObject(
       client, context_id, expression, &got_object, &element_id);
   if (status.IsError())
     return status;
   if (!got_object) {
     *found_node = false;
     return Status(kOk);
@@ skipping 20 matching lines @@
   if (status.IsError())
     return status;
 
   if (!cmd_result->GetInteger("nodeId", node_id))
     return Status(kUnknownError, "DOM.requestNode missing int 'nodeId'");
   *found_node = true;
   return Status(kOk);
 }
 
 }  // namespace internal