Move compilation queues into BackgroundCompiler class

runtime/vm/compiler.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 1596 matching lines @@
   prefix_invalidation_gen_ = queue->PopBackInteger();
   field_invalidation_gen_ = queue->PopBackInteger();
   cha_invalidation_gen_ = queue->PopBackInteger();
   result_code_ = queue->PopBackCode();
 }
 
 
 BackgroundCompiler::BackgroundCompiler(Isolate* isolate)
     : isolate_(isolate), running_(true), done_(new bool()),
       queue_monitor_(new Monitor()), done_monitor_(new Monitor()),
-      function_queue_length_(0) {
+      function_queue_length_(0),
+      compilation_function_queue_(GrowableObjectArray::null()),
+      compilation_result_queue_(GrowableObjectArray::null()) {
   *done_ = false;
 }
 
 
 void BackgroundCompiler::Run() {
   while (running_) {
     // Maybe something is already in the queue, check first before waiting
     // to be notified.
     Thread::EnterIsolateAsHelper(isolate_);
     {
@@ skipping 67 matching lines @@
     }
     if (function.usage_counter() < 0) {
       // Reset to 0 so that it can be recompiled if needed.
       function.set_usage_counter(0);
     }
   }
 }
 
 
 GrowableObjectArray* BackgroundCompiler::FunctionsQueue() const {
-  return
-      &GrowableObjectArray::ZoneHandle(isolate_->compilation_function_queue());
+  return &GrowableObjectArray::ZoneHandle(compilation_function_queue_);
 }
 
 
 GrowableObjectArray* BackgroundCompiler::ResultQueue() const {
-  return &GrowableObjectArray::ZoneHandle(isolate_->compilation_result_queue());
+  return &GrowableObjectArray::ZoneHandle(compilation_result_queue_);
 }
 
 
 void BackgroundCompiler::AddFunction(const Function& f) {
   MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(FunctionsQueue());
   queue.PushFrontFunction(f);
   set_function_queue_length(queue.Length());
   // Notify waiting background compiler task.
   ml.Notify();
@@ skipping 16 matching lines @@
 }
 
 
 void BackgroundCompiler::AddResult(const BackgroundCompilationResult& value) {
   MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(ResultQueue());
   value.PushOnQueue(&queue);
 }
 
 
+void BackgroundCompiler::set_compilation_function_queue(
+    const GrowableObjectArray& value) {
+  compilation_function_queue_ = value.raw();
+}
+
+
+void BackgroundCompiler::set_compilation_result_queue(
+    const GrowableObjectArray& value) {
+  compilation_result_queue_ = value.raw();
+}
+
+
+void BackgroundCompiler::VisitPointers(ObjectPointerVisitor* visitor) {
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(
+      &compilation_function_queue_));
+
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(
+      &compilation_result_queue_));
+}
+
+
 void BackgroundCompiler::Stop(BackgroundCompiler* task) {
   ASSERT(Isolate::Current()->background_compiler() == task);
   if (task == NULL) {
     return;
   }
   Monitor* monitor = task->queue_monitor_;
   Monitor* done_monitor = task->done_monitor_;
   bool* task_done = task->done_;
   // Wake up compiler task and stop it.
   {
@@ skipping 18 matching lines @@
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   bool start_task = false;
   Isolate* isolate = thread->isolate();
   {
     MutexLocker ml(isolate->mutex());
     if (isolate->background_compiler() == NULL) {
       BackgroundCompiler* task = new BackgroundCompiler(isolate);
       isolate->set_background_compiler(task);
-      isolate->set_compilation_function_queue(GrowableObjectArray::Handle(
+      task->set_compilation_function_queue(GrowableObjectArray::Handle(
           thread->zone(), GrowableObjectArray::New()));
-      isolate->set_compilation_result_queue(GrowableObjectArray::Handle(
+      task->set_compilation_result_queue(GrowableObjectArray::Handle(
           thread->zone(), GrowableObjectArray::New()));
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart