[compiler-dispatcher] make it so that we can always parse on bg threads

test/unittests/compiler-dispatcher/compiler-dispatcher-job-unittest.cc

 // Copyright 2016 the V8 project 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 <memory>
 
 #include "include/v8.h"
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 11 matching lines @@
 namespace v8 {
 namespace internal {
 
 class CompilerDispatcherJobTest : public TestWithContext {
  public:
   CompilerDispatcherJobTest() : tracer_(i_isolate()) {}
   ~CompilerDispatcherJobTest() override {}
 
   CompilerDispatcherTracer* tracer() { return &tracer_; }
 
- private:
-  CompilerDispatcherTracer tracer_;
-
-  DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherJobTest);
-};
-
-class IgnitionCompilerDispatcherJobTest : public CompilerDispatcherJobTest {
- public:
-  IgnitionCompilerDispatcherJobTest() {}
-  ~IgnitionCompilerDispatcherJobTest() override {}
-
   static void SetUpTestCase() {
     old_flag_ = i::FLAG_ignition;
     i::FLAG_ignition = true;
     TestWithContext::SetUpTestCase();
   }
 
   static void TearDownTestCase() {
     TestWithContext::TearDownTestCase();
     i::FLAG_ignition = old_flag_;
   }
 
  private:
+  CompilerDispatcherTracer tracer_;
   static bool old_flag_;
-  DISALLOW_COPY_AND_ASSIGN(IgnitionCompilerDispatcherJobTest);
+
+  DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherJobTest);
 };
 
-bool IgnitionCompilerDispatcherJobTest::old_flag_;
+bool CompilerDispatcherJobTest::old_flag_;
 
 namespace {
 
 const char test_script[] = "(x) { x*x; }";
 
 class ScriptResource : public v8::String::ExternalOneByteStringResource {
  public:
   ScriptResource(const char* data, size_t length)
       : data_(data), length_(length) {}
   ~ScriptResource() override = default;
@@ skipping 33 matching lines @@
 }
 
 }  // namespace
 
 TEST_F(CompilerDispatcherJobTest, Construct) {
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       i_isolate(), tracer(), CreateSharedFunctionInfo(i_isolate(), nullptr),
       FLAG_stack_size));
 }
 
-TEST_F(CompilerDispatcherJobTest, CanParseOnBackgroundThread) {
-  {
-    std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
-        i_isolate(), tracer(), CreateSharedFunctionInfo(i_isolate(), nullptr),
-        FLAG_stack_size));
-    ASSERT_FALSE(job->can_parse_on_background_thread());
-  }
-  {
-    ScriptResource script(test_script, strlen(test_script));
-    std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
-        i_isolate(), tracer(), CreateSharedFunctionInfo(i_isolate(), &script),
-        FLAG_stack_size));
-    ASSERT_TRUE(job->can_parse_on_background_thread());
-  }
-}
-
 TEST_F(CompilerDispatcherJobTest, StateTransitions) {
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       i_isolate(), tracer(), CreateSharedFunctionInfo(i_isolate(), nullptr),
       FLAG_stack_size));
 
   ASSERT_TRUE(job->status() == CompileJobStatus::kInitial);
   job->PrepareToParseOnMainThread();
   ASSERT_TRUE(job->status() == CompileJobStatus::kReadyToParse);
   job->Parse();
   ASSERT_TRUE(job->status() == CompileJobStatus::kParsed);
@@ skipping 145 matching lines @@
     job_->Compile();
     semaphore_->Signal();
   }
 
  private:
   CompilerDispatcherJob* job_;
   base::Semaphore* semaphore_;
   DISALLOW_COPY_AND_ASSIGN(CompileTask);
 };
 
-TEST_F(IgnitionCompilerDispatcherJobTest, CompileOnBackgroundThread) {
+TEST_F(CompilerDispatcherJobTest, CompileOnBackgroundThread) {
   const char* raw_script =
       "(a, b) {\n"
       "  var c = a + b;\n"
       "  function bar() { return b }\n"
       "  var d = { foo: 100, bar : bar() }\n"
       "  return bar;"
       "}";
   ScriptResource script(raw_script, strlen(raw_script));
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       i_isolate(), tracer(), CreateSharedFunctionInfo(i_isolate(), &script),
       100));
 
   job->PrepareToParseOnMainThread();
   job->Parse();
   job->FinalizeParsingOnMainThread();
   job->PrepareToCompileOnMainThread();
-  ASSERT_TRUE(job->can_compile_on_background_thread());
 
   base::Semaphore semaphore(0);
   CompileTask* background_task = new CompileTask(job.get(), &semaphore);
   V8::GetCurrentPlatform()->CallOnBackgroundThread(background_task,
                                                    Platform::kShortRunningTask);
   semaphore.Wait();
   ASSERT_TRUE(job->FinalizeCompilingOnMainThread());
   ASSERT_TRUE(job->status() == CompileJobStatus::kDone);
 
   job->ResetOnMainThread();
@@ skipping 26 matching lines @@
   Handle<JSFunction> e = Handle<JSFunction>::cast(RunJS(isolate(), "f();"));
 
   ASSERT_FALSE(e->shared()->HasBaselineCode());
 
   job->ResetOnMainThread();
   ASSERT_TRUE(job->status() == CompileJobStatus::kInitial);
 }
 
 }  // namespace internal
 }  // namespace v8