Support reftest-wait in web-platform-tests

content/shell/test_runner/test_runner.cc

 // Copyright 2014 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/shell/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 81 matching lines @@
 }
 
 }  // namespace
 
 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<TestRunner> test_runner,
                       base::WeakPtr<TestRunnerForSpecificView> view_test_runner,
-                      WebLocalFrame* frame);
+                      WebLocalFrame* frame,
+                      bool is_web_platform_tests_mode);
 
  private:
   explicit TestRunnerBindings(
       base::WeakPtr<TestRunner> test_runner,
       base::WeakPtr<TestRunnerForSpecificView> view_test_runner);
   ~TestRunnerBindings() override;
 
   // gin::Wrappable:
   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
@@ skipping 184 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestRunnerBindings);
 };
 
 gin::WrapperInfo TestRunnerBindings::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 // static
 void TestRunnerBindings::Install(
     base::WeakPtr<TestRunner> test_runner,
     base::WeakPtr<TestRunnerForSpecificView> view_test_runner,
-    WebLocalFrame* frame) {
+    WebLocalFrame* frame,
+    bool is_web_platform_tests_mode) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
   TestRunnerBindings* wrapped =
       new TestRunnerBindings(test_runner, view_test_runner);
   gin::Handle<TestRunnerBindings> bindings =
       gin::CreateHandle(isolate, wrapped);
   if (bindings.IsEmpty())
     return;
   v8::Local<v8::Object> global = context->Global();
   v8::Local<v8::Value> v8_bindings = bindings.ToV8();
 
   std::vector<std::string> names;
   names.push_back("testRunner");
   names.push_back("layoutTestController");
   for (size_t i = 0; i < names.size(); ++i)
     global->Set(gin::StringToV8(isolate, names[i].c_str()), v8_bindings);
+
+  // The web-platform-tests suite require that reference comparison is delayed
+  // for any test with a 'reftest-wait' class on the root element, until that
+  // class attribute is removed. To support this approach, we inject some
+  // JavaScript that implements the same behavior using TestRunner.
+  //
+  // See http://web-platform-tests.org/writing-tests/reftests.html for more
+  // details about reference tests in the web-platform-tests suite.
+  if (is_web_platform_tests_mode) {
+    frame->executeScript(blink::WebString(
+        R"(window.addEventListener('load', function() {
+          if (!window.testRunner) {
+            return;
+          }
+          const target = document.documentElement;
+          if (target != null && target.classList.contains('reftest-wait')) {
+            window.testRunner.waitUntilDone();
+            const observer = new MutationObserver(function(mutations) {
+              mutations.forEach(function(mutation) {
+                if (!target.classList.contains('reftest-wait')) {
+                  window.testRunner.notifyDone();
+                }
+              });
+            });
+            const config = {attributes: true};
+            observer.observe(target, config);
+          }
+        });)"));
+  }
 }
 
 TestRunnerBindings::TestRunnerBindings(
     base::WeakPtr<TestRunner> runner,
     base::WeakPtr<TestRunnerForSpecificView> view_runner)
     : runner_(runner), view_runner_(view_runner) {}
 
 TestRunnerBindings::~TestRunnerBindings() {}
 
 gin::ObjectTemplateBuilder TestRunnerBindings::GetObjectTemplateBuilder(
@@ skipping 1279 matching lines @@
       effective_connection_type_(
           blink::WebEffectiveConnectionType::TypeUnknown),
       weak_factory_(this) {}
 
 TestRunner::~TestRunner() {}
 
 void TestRunner::Install(
     WebLocalFrame* frame,
     base::WeakPtr<TestRunnerForSpecificView> view_test_runner) {
   TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), view_test_runner,
-                              frame);
+                              frame, is_web_platform_tests_mode());
 }
 
 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   mock_content_settings_client_->SetDelegate(delegate);
   spellcheck_->SetDelegate(delegate);
   if (speech_recognizer_)
     speech_recognizer_->SetDelegate(delegate);
 }
 
@@ skipping 1168 matching lines @@
 
 void TestRunner::NotifyDone() {
   if (layout_test_runtime_flags_.wait_until_done() && !topLoadingFrame() &&
       !will_navigate_ && work_queue_.is_empty())
     delegate_->TestFinished();
   layout_test_runtime_flags_.set_wait_until_done(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 }  // namespace test_runner