Remove DOMAutomationController::automation_id_

content/public/test/browser_test_utils.cc

 // Copyright (c) 2012 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 "content/public/test/browser_test_utils.h"
 
 #include <stddef.h>
 #include <tuple>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/guid.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
@@ skipping 373 matching lines @@
 }
 
 // Queries for video input devices on the current system using the getSources
 // API.
 //
 // This does not guarantee that a getUserMedia with video will succeed, as the
 // camera could be busy for instance.
 //
 // Returns has-video-input-device to the test if there is a webcam available,
 // no-video-input-devices otherwise.
-const char kHasVideoInputDeviceOnSystem[] =
-    "(function() {"
-      "navigator.mediaDevices.enumerateDevices()"
-      ".then(function(devices) {"
-        "devices.forEach(function(device) {"
-          "if (device.kind == 'videoinput') {"
-            "window.domAutomationController.send('has-video-input-device');"
-            "return;"
-          "}"
-        "});"
-        "window.domAutomationController.send('no-video-input-devices');"
-      "});"
-    "})()";
+const char kHasVideoInputDeviceOnSystem[] = R"(
+    (function() {
+      navigator.mediaDevices.enumerateDevices()
+      .then(function(devices) {
+        if (devices.some((device) => device.kind == 'videoinput')) {
+          window.domAutomationController.send('has-video-input-device');
+        } else {
+          window.domAutomationController.send('no-video-input-devices');
+        }
+      });
+    })()
+)";
 
 const char kHasVideoInputDevice[] = "has-video-input-device";
 
 }  // namespace
 
 bool NavigateIframeToURL(WebContents* web_contents,
                          std::string iframe_id,
                          const GURL& url) {
   std::string script = base::StringPrintf(
       "setTimeout(\""
@@ skipping 370 matching lines @@
 RenderFrameHost* ConvertToRenderFrameHost(RenderViewHost* render_view_host) {
   return render_view_host->GetMainFrame();
 }
 
 RenderFrameHost* ConvertToRenderFrameHost(RenderFrameHost* render_frame_host) {
   return render_frame_host;
 }
 
 bool ExecuteScript(const ToRenderFrameHost& adapter,
                    const std::string& script) {
-  std::string new_script =
-      script + ";window.domAutomationController.send(0);";
-  return ExecuteScriptHelper(adapter.render_frame_host(), new_script, true,
-                             nullptr);
+  // TODO(lukasza): ExecuteScript should just call
+  // ExecuteJavaScriptWithUserGestureForTests and avoid modifying the original
+  // script (and at that point we should merge it with and remove
+  // ExecuteUnmodifiedScript).  This is difficult to change, because many tests
+  // depend on the message loop pumping done by ExecuteScriptHelper below (this
+  // is fragile - these tests should wait on a more specific thing instead).
+
+  std::string expected_response = "ExecuteScript-" + base::GenerateGUID();
+  std::string new_script = base::StringPrintf(
+      R"( %s;  // Original script.
+          window.domAutomationController.send('%s'); )",
+      script.c_str(), expected_response.c_str());
+
+  std::string actual_response;
+  if (!ExecuteScriptAndExtractString(adapter, new_script, &actual_response))
+    return false;
+  DCHECK_EQ(expected_response, actual_response);
+
+  return true;
 }
 
 bool ExecuteScriptWithoutUserGesture(const ToRenderFrameHost& adapter,
                                      const std::string& script) {
   std::string new_script = script + ";window.domAutomationController.send(0);";

[ncarter (slow), 2017/07/06 18:14:31]

Should this match what ExecuteScript does with the GUID?

[Łukasz Anforowicz, 2017/07/06 20:11:02]

Doh... :-/  You're right - these checks should apply to both.  I've moved the
common code to a helper function in the anonymous namespace.

   return ExecuteScriptHelper(adapter.render_frame_host(), new_script, false,
                              nullptr);
 }
 
+void ExecuteUnmodifiedScript(const ToRenderFrameHost& adapter,
+                             const std::string& script) {

[ncarter (slow), 2017/07/06 18:14:30]

You asked for feedback on the name.

I would be tempted to call this ExecuteScriptWithoutWaiting(),
ExecuteScriptAsync(), or EnqueueScriptExecution(), or something else to
emphasize the async vs. sync nature, rather than emphasizing the fact that the
script isn't modified in the process.

[Łukasz Anforowicz, 2017/07/06 20:11:02]

Thanks for the feedback.  I've picked ExecuteScriptAsync for the name.

+  adapter.render_frame_host()->ExecuteJavaScriptWithUserGestureForTests(
+      base::UTF8ToUTF16(script));
+}
+
 bool ExecuteScriptAndExtractDouble(const ToRenderFrameHost& adapter,
                                    const std::string& script, double* result) {
   DCHECK(result);
   std::unique_ptr<base::Value> value;
   if (!ExecuteScriptHelper(adapter.render_frame_host(), script, true, &value) ||
       !value.get()) {
     return false;
   }
 
   return value->GetAsDouble(result);
@@ skipping 150 matching lines @@
     scoped_refptr<base::RefCountedMemory> bytes =
         ResourceBundle::GetSharedInstance().LoadDataResourceBytes(*iter);
 
     if (HasGzipHeader(*bytes))
       AppendGzippedResource(*bytes, &script);
     else
       script.append(bytes->front_as<char>(), bytes->size());
 
     script.append("\n");
   }
-  if (!ExecuteScript(web_contents, script))
-    return false;
+  ExecuteUnmodifiedScript(web_contents, script);
 
   DOMMessageQueue message_queue;
-  if (!ExecuteScript(web_contents, "runTests()"))
-    return false;
+  ExecuteUnmodifiedScript(web_contents, "runTests()");
 
   std::string message;
   do {
     if (!message_queue.WaitForMessage(&message))
       return false;
   } while (message.compare("\"PENDING\"") == 0);
 
   return message.compare("\"SUCCESS\"") == 0;
 }
 
@@ skipping 467 matching lines @@
                  Source<WebContents>(web_contents));
 }
 
 DOMMessageQueue::~DOMMessageQueue() {}
 
 void DOMMessageQueue::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   Details<std::string> dom_op_result(details);
   message_queue_.push(*dom_op_result.ptr());
-  if (message_loop_runner_.get())
+  if (message_loop_runner_)
     message_loop_runner_->Quit();
 }
 
 void DOMMessageQueue::RenderProcessGone(base::TerminationStatus status) {
   VLOG(0) << "DOMMessageQueue::RenderProcessGone " << status;
   switch (status) {
     case base::TERMINATION_STATUS_NORMAL_TERMINATION:
     case base::TERMINATION_STATUS_STILL_RUNNING:
       break;
     default:
+      renderer_crashed_ = true;
       if (message_loop_runner_.get())
         message_loop_runner_->Quit();
       break;
   }
 }
 
 void DOMMessageQueue::ClearQueue() {
   message_queue_ = std::queue<std::string>();
 }
 
 bool DOMMessageQueue::WaitForMessage(std::string* message) {
   DCHECK(message);
-  if (message_queue_.empty()) {
+  if (!renderer_crashed_ && message_queue_.empty()) {
     // This will be quit when a new message comes in.
     message_loop_runner_ =
         new MessageLoopRunner(MessageLoopRunner::QuitMode::IMMEDIATE);
     message_loop_runner_->Run();
   }
   return PopMessage(message);
 }
 
 bool DOMMessageQueue::PopMessage(std::string* message) {
   DCHECK(message);
-  if (message_queue_.empty())
+  if (renderer_crashed_ || message_queue_.empty())
     return false;
   *message = message_queue_.front();
   message_queue_.pop();
   return true;
 }
 
 class WebContentsAddedObserver::RenderViewCreatedObserver
     : public WebContentsObserver {
  public:
   explicit RenderViewCreatedObserver(WebContents* web_contents)
@@ skipping 564 matching lines @@
   RenderWidgetHostViewAura* rwhva =
       static_cast<RenderWidgetHostViewAura*>(rwhv);
   rwhva->SetOverscrollControllerForTesting(std::move(mock));
 
   return raw_mock;
 }
 
 #endif  // defined(USE_AURA)
 
 }  // namespace content