Remove V8RecrusionScope, cleanup call sites.

chrome/test/base/v8_unit_test.cc

 // Copyright (c) 2011 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/base/v8_unit_test.h"
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/common/chrome_paths.h"
 #include "third_party/WebKit/public/web/WebKit.h"
-#include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 
 namespace {
 
 // |args| are passed through the various JavaScript logging functions such as
 // console.log. Returns a string appropriate for logging with LOG(severity).
 std::string LogArgs2String(const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string message;
   bool first = true;
   for (int i = 0; i < args.Length(); i++) {
     v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
@@ skipping 64 matching lines @@
   g_test_result_ok = false;
   std::string test_js;
   if (!ExecuteJavascriptLibraries())
     return false;
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, context_);
   v8::Context::Scope context_scope(context);
-  blink::WebScopedMicrotaskSuppression microtasks_scope;
+  v8::MicrotasksScope microtasks(
+      isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
 
   v8::Local<v8::Value> function_property =
       context->Global()->Get(v8::String::NewFromUtf8(isolate, "runTest"));
   EXPECT_FALSE(function_property.IsEmpty());
   if (::testing::Test::HasNonfatalFailure())
     return false;
   EXPECT_TRUE(function_property->IsFunction());
   if (::testing::Test::HasNonfatalFailure())
     return false;
   v8::Local<v8::Function> function =
@@ skipping 94 matching lines @@
           isolate, value.c_str(), v8::String::kNormalString, value.length()));
 }
 
 void V8UnitTest::ExecuteScriptInContext(const base::StringPiece& script_source,
                                         const base::StringPiece& script_name) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, context_);
   v8::Context::Scope context_scope(context);
-  blink::WebScopedMicrotaskSuppression microtasks_scope;
+  v8::MicrotasksScope microtasks(
+      isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
   v8::Local<v8::String> source =
       v8::String::NewFromUtf8(isolate,
                               script_source.data(),
                               v8::String::kNormalString,
                               script_source.size());
   v8::Local<v8::String> name =
       v8::String::NewFromUtf8(isolate,
                               script_name.data(),
                               v8::String::kNormalString,
                               script_name.size());
@@ skipping 28 matching lines @@
   }
   return str;
 }
 
 void V8UnitTest::TestFunction(const std::string& function_name) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, context_);
   v8::Context::Scope context_scope(context);
-  blink::WebScopedMicrotaskSuppression microtasks_scope;
+  v8::MicrotasksScope microtasks(
+      isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
 
   v8::Local<v8::Value> function_property = context->Global()->Get(
       v8::String::NewFromUtf8(isolate, function_name.c_str()));
   ASSERT_FALSE(function_property.IsEmpty());
   ASSERT_TRUE(function_property->IsFunction());
   v8::Local<v8::Function> function =
       v8::Local<v8::Function>::Cast(function_property);
 
   v8::TryCatch try_catch(isolate);
   v8::Local<v8::Value> result = function->Call(context->Global(), 0, NULL);
@@ skipping 30 matching lines @@
   v8::Local<v8::Array> test_result(args[1].As<v8::Array>());
   EXPECT_EQ(2U, test_result->Length());
   if (::testing::Test::HasNonfatalFailure())
     return;
   g_test_result_ok = test_result->Get(0)->BooleanValue();
   if (!g_test_result_ok) {
     v8::String::Utf8Value message(test_result->Get(1));
     LOG(ERROR) << *message;
   }
 }