Allow test runner to run a callback when finishing a spellcheck request

components/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 "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 223 matching lines @@
                      const std::string& origin,
                      const std::string& embedding_origin);
   void SetPluginsAllowed(bool allowed);
   void SetPluginsEnabled(bool enabled);
   void SetPointerLockWillFailSynchronously();
   void SetPointerLockWillRespondAsynchronously();
   void SetPopupBlockingEnabled(bool block_popups);
   void SetPrinting();
   void SetScriptsAllowed(bool allowed);
   void SetShouldStayOnPageAfterHandlingBeforeUnload(bool value);
+  void SetSpellCheckResolvedCallback(v8::Local<v8::Function> callback);
   void SetStorageAllowed(bool allowed);
   void SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements);
   void SetTextDirection(const std::string& direction_name);
   void SetTextSubpixelPositioning(bool value);
   void SetUseMockTheme(bool use);
   void SetViewSourceForFrame(const std::string& name, bool enabled);
   void SetWillSendRequestClearHeader(const std::string& header);
   void SetWindowIsKey(bool value);
   void SetXSSAuditorEnabled(bool enabled);
   void ShowWebInspector(gin::Arguments* args);
@@ skipping 299 matching lines @@
       .SetMethod("setPointerLockWillRespondAsynchronously",
                  &TestRunnerBindings::SetPointerLockWillRespondAsynchronously)
       .SetMethod("setPopupBlockingEnabled",
                  &TestRunnerBindings::SetPopupBlockingEnabled)
       .SetMethod("setPrinting", &TestRunnerBindings::SetPrinting)
       .SetMethod("setScriptsAllowed", &TestRunnerBindings::SetScriptsAllowed)
       .SetMethod("setScrollbarPolicy", &TestRunnerBindings::NotImplemented)
       .SetMethod(
           "setShouldStayOnPageAfterHandlingBeforeUnload",
           &TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload)
+      .SetMethod("setSpellCheckResolvedCallback",
+                 &TestRunnerBindings::SetSpellCheckResolvedCallback)
       .SetMethod("setStorageAllowed", &TestRunnerBindings::SetStorageAllowed)
       .SetMethod("setTabKeyCyclesThroughElements",
                  &TestRunnerBindings::SetTabKeyCyclesThroughElements)
       .SetMethod("setTextDirection", &TestRunnerBindings::SetTextDirection)
       .SetMethod("setTextSubpixelPositioning",
                  &TestRunnerBindings::SetTextSubpixelPositioning)
       .SetMethod("setUseDashboardCompatibilityMode",
                  &TestRunnerBindings::NotImplemented)
       .SetMethod("setUseMockTheme", &TestRunnerBindings::SetUseMockTheme)
       .SetMethod("setViewSourceForFrame",
@@ skipping 168 matching lines @@
 
   if (runner_)
     runner_->SetEffectiveConnectionType(web_type);
 }
 
 void TestRunnerBindings::SetMockSpellCheckerEnabled(bool enabled) {
   if (runner_)
     runner_->SetMockSpellCheckerEnabled(enabled);
 }
 
+void TestRunnerBindings::SetSpellCheckResolvedCallback(
+    v8::Local<v8::Function> callback) {
+  if (runner_)
+    runner_->spellcheck_->SetSpellCheckResolvedCallback(callback);
+}
+
 v8::Local<v8::Value>
 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
     int world_id, const std::string& script) {
   if (!view_runner_ || world_id <= 0 || world_id >= (1 << 29))
     return v8::Local<v8::Value>();
   return view_runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
                                                                    script);
 }
 
 void TestRunnerBindings::EvaluateScriptInIsolatedWorld(
@@ skipping 912 matching lines @@
   SetUseMockTheme(true);
 
   weak_factory_.InvalidateWeakPtrs();
   work_queue_.Reset();
 
   if (close_remaining_windows_ && delegate_)
     delegate_->CloseRemainingWindows();
   else
     close_remaining_windows_ = true;
 
-  spellcheck_->SetEnabled(false);
+  spellcheck_->Reset();
 }
 
 void TestRunner::SetTestIsRunning(bool running) {
   test_is_running_ = running;
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
   return layout_test_runtime_flags_.dump_editting_callbacks();
 }
 
@@ skipping 1086 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