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>
 
@@ skipping 395 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) {
+        var found = false;
+        devices.forEach(function(device) {
+          if (device.kind == 'videoinput') {
+            window.domAutomationController.send('has-video-input-device');

[ncarter (slow), 2017/07/05 20:30:44]

looks like there could still be multiple sends() here if there are multiple
devices in the result with type 'videoinput'.

This can be fixed by either moving the 'has-video-input-device' send outside the
forEach. You could also use Array.prototype.some instead of
Array.prototype.forEach here:

if (devices.some((device) => device.kind == 'videoinput')) {
  window.domAutomationController.send('has-video-input-device');
} else {
  window.domAutomationController.send('no-video-input-devices');
}

[Łukasz Anforowicz, 2017/07/06 15:48:02]

Good catch.  Thanks for the "devices.some" suggestion - this is what I've
picked.

+            found = true;
+          }
+        });
+        if (!found) {
+          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) {
+  // TODO(lukasza): ExecuteScript should just call
+  // ExecuteJavaScriptWithUserGestureForTests and avoid modifying the original
+  // script (and at that point we should 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).

[ncarter (slow), 2017/07/05 20:30:44]

We could make this more robust by generating a GUID here, making this delegate
to ExecuteScriptAndExtractString, and then asserting that the value we get back
is equal to the GUID.

I think it's fine for tests to rely on the ordering guarantees of ExecuteScript
doing an IPC round trip, but I'm glad that you're adding an async variant too.

[Łukasz Anforowicz, 2017/07/06 15:48:02]

Done.
Ok.  I forgot examples that I found long time ago, where the test could made for
a new window (via WebContentsAddedObserver), rather than depend on the
accidental timing/pumping inside ExecuteScript.  Still - I think the situation
after this CL is ok.
Ok.  Any feedback on the name (ExecuteUnmodifiedScript)?

   std::string new_script =
       script + ";window.domAutomationController.send(0);";
   return ExecuteScriptHelper(adapter.render_frame_host(), new_script, true,
                              nullptr);
 }
 
 bool ExecuteScriptWithoutUserGesture(const ToRenderFrameHost& adapter,
                                      const std::string& script) {
   std::string new_script = script + ";window.domAutomationController.send(0);";
   return ExecuteScriptHelper(adapter.render_frame_host(), new_script, false,
                              nullptr);
 }
 
+void ExecuteUnmodifiedScript(const ToRenderFrameHost& adapter,
+                             const std::string& script) {
+  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 154 matching lines @@
       AppendGzippedResource(*bytes, &script);
     else
       script.append(bytes->front_as<char>(), bytes->size());
 
     script.append("\n");
   }
   if (!ExecuteScript(web_contents, script))
     return false;
 
   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