Reland: [Compiler] Enable handles created during parsing and scope analysis to be deferred.

src/compiler-dispatcher/compiler-dispatcher.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 "src/compiler-dispatcher/compiler-dispatcher.h"
 
 #include "include/v8-platform.h"
 #include "include/v8.h"
 #include "src/base/platform/time.h"
 #include "src/cancelable-task.h"
@@ skipping 269 matching lines @@
     function->ShortPrint();
     PrintF("\n");
   }
   JobMap::const_iterator job = GetJobFor(function);
   DoNextStepOnMainThread(isolate_, job->second.get(),
                          ExceptionHandling::kSwallow);
   ConsiderJobForBackgroundProcessing(job->second.get());
   return true;
 }
 
-bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function,
-                                 FunctionLiteral* literal) {
+bool CompilerDispatcher::Enqueue(
+    Handle<SharedFunctionInfo> function, FunctionLiteral* literal,
+    std::shared_ptr<Zone> parse_zone,
+    std::shared_ptr<DeferredHandles> parse_handles,
+    std::shared_ptr<DeferredHandles> compile_handles) {
   if (!CanEnqueue(function)) return false;
   if (IsEnqueued(function)) return true;
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: enqueuing ");
     function->ShortPrint();
     PrintF(" for compile\n");
   }
 
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
-      isolate_, tracer_.get(), function, literal, max_stack_size_));
+      isolate_, tracer_.get(), function, literal, parse_zone, parse_handles,
+      compile_handles, max_stack_size_));
   std::pair<int, int> key(Script::cast(function->script())->id(),
                           function->function_literal_id());
   jobs_.insert(std::make_pair(key, std::move(job)));
   ScheduleIdleTaskIfNeeded();
   return true;
 }
 
-bool CompilerDispatcher::EnqueueAndStep(Handle<SharedFunctionInfo> function,
-                                        FunctionLiteral* literal) {
-  if (!Enqueue(function, literal)) return false;
+bool CompilerDispatcher::EnqueueAndStep(
+    Handle<SharedFunctionInfo> function, FunctionLiteral* literal,
+    std::shared_ptr<Zone> parse_zone,
+    std::shared_ptr<DeferredHandles> parse_handles,
+    std::shared_ptr<DeferredHandles> compile_handles) {
+  if (!Enqueue(function, literal, parse_zone, parse_handles, compile_handles)) {
+    return false;
+  }
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: stepping ");
     function->ShortPrint();
     PrintF("\n");
   }
   JobMap::const_iterator job = GetJobFor(function);
   DoNextStepOnMainThread(isolate_, job->second.get(),
                          ExceptionHandling::kSwallow);
   ConsiderJobForBackgroundProcessing(job->second.get());
@@ skipping 370 matching lines @@
       lock.reset();
       DoNextStepOnMainThread(isolate_, job->second.get(),
                              ExceptionHandling::kSwallow);
     }
   }
   if (jobs_.size() > too_long_jobs) ScheduleIdleTaskIfNeeded();
 }
 
 }  // namespace internal
 }  // namespace v8