VM: Re-format to use at most one newline between functions

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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/isolate.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
 #include "vm/atomic.h"
 #include "vm/class_finalizer.h"
 #include "vm/code_observers.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate_reload.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
 #include "vm/message_handler.h"
+#include "vm/object.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
-#include "vm/object.h"
 #include "vm/os_thread.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/safepoint.h"
 #include "vm/service.h"
 #include "vm/service_event.h"
 #include "vm/service_isolate.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/thread_interrupter.h"
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/timeline_analysis.h"
 #include "vm/timer.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 
-
 namespace dart {
 
 DECLARE_FLAG(bool, print_metrics);
 DECLARE_FLAG(bool, timing);
 DECLARE_FLAG(bool, trace_service);
 DECLARE_FLAG(bool, warn_on_pause_with_no_debugger);
 
 // Reload flags.
 DECLARE_FLAG(bool, check_reloaded);
 DECLARE_FLAG(int, reload_every);
 DECLARE_FLAG(bool, reload_every_back_off);
 DECLARE_FLAG(bool, trace_reload);
 
-
 #if !defined(PRODUCT)
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 // --enable-checked-mode and --checked both enable checked mode which is
 // equivalent to setting --enable-asserts and --enable-type-checks.
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     enable_checked_mode,
                     "Enable checked mode.");
 
 DEFINE_FLAG_HANDLER(CheckedModeHandler, checked, "Enable checked mode.");
 #endif  // !defined(PRODUCT)
 
-
 // Quick access to the locally defined thread() and isolate() methods.
 #define T (thread())
 #define I (isolate())
 
 #if defined(DEBUG)
 // Helper class to ensure that a live origin_id is never reused
 // and assigned to an isolate.
 class VerifyOriginId : public IsolateVisitor {
  public:
   explicit VerifyOriginId(Dart_Port id) : id_(id) {}
 
   void VisitIsolate(Isolate* isolate) { ASSERT(isolate->origin_id() != id_); }
 
  private:
   Dart_Port id_;
   DISALLOW_COPY_AND_ASSIGN(VerifyOriginId);
 };
 #endif
 
-
 static uint8_t* malloc_allocator(uint8_t* ptr,
                                  intptr_t old_size,
                                  intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 static void malloc_deallocator(uint8_t* ptr) {
   free(reinterpret_cast<void*>(ptr));
 }
 
-
 static void SerializeObject(const Instance& obj,
                             uint8_t** obj_data,
                             intptr_t* obj_len,
                             bool allow_any_object) {
   MessageWriter writer(obj_data, &malloc_allocator, &malloc_deallocator,
                        allow_any_object);
   writer.WriteMessage(obj);
   *obj_len = writer.BytesWritten();
 }
 
 // TODO(zra): Allocation of Message objects should be centralized.
 static Message* SerializeMessage(Dart_Port dest_port, const Instance& obj) {
   if (ApiObjectConverter::CanConvert(obj.raw())) {
     return new Message(dest_port, obj.raw(), Message::kNormalPriority);
   } else {
     uint8_t* obj_data;
     intptr_t obj_len;
     SerializeObject(obj, &obj_data, &obj_len, false);
     return new Message(dest_port, obj_data, obj_len, Message::kNormalPriority);
   }
 }
 
-
 bool IsolateVisitor::IsVMInternalIsolate(Isolate* isolate) const {
   return ((isolate == Dart::vm_isolate()) ||
           ServiceIsolate::IsServiceIsolateDescendant(isolate));
 }
 
-
 NoOOBMessageScope::NoOOBMessageScope(Thread* thread) : StackResource(thread) {
   thread->DeferOOBMessageInterrupts();
 }
 
-
 NoOOBMessageScope::~NoOOBMessageScope() {
   thread()->RestoreOOBMessageInterrupts();
 }
 
-
 NoReloadScope::NoReloadScope(Isolate* isolate, Thread* thread)
     : StackResource(thread), isolate_(isolate) {
   ASSERT(isolate_ != NULL);
   AtomicOperations::FetchAndIncrement(&(isolate_->no_reload_scope_depth_));
   ASSERT(AtomicOperations::LoadRelaxed(&(isolate_->no_reload_scope_depth_)) >=
          0);
 }
 
-
 NoReloadScope::~NoReloadScope() {
   AtomicOperations::FetchAndDecrement(&(isolate_->no_reload_scope_depth_));
   ASSERT(AtomicOperations::LoadRelaxed(&(isolate_->no_reload_scope_depth_)) >=
          0);
 }
 
-
 void Isolate::RegisterClass(const Class& cls) {
 #if !defined(PRODUCT)
   if (IsReloading()) {
     reload_context()->RegisterClass(cls);
     return;
   }
 #endif  // !defined(PRODUCT)
   class_table()->Register(cls);
 }
 
-
 void Isolate::RegisterClassAt(intptr_t index, const Class& cls) {
   class_table()->RegisterAt(index, cls);
 }
 
-
 void Isolate::ValidateClassTable() {
   class_table()->Validate();
 }
 
-
 void Isolate::SendInternalLibMessage(LibMsgId msg_id, uint64_t capability) {
   const Array& msg = Array::Handle(Array::New(3));
   Object& element = Object::Handle();
 
   element = Smi::New(Message::kIsolateLibOOBMsg);
   msg.SetAt(0, element);
   element = Smi::New(msg_id);
   msg.SetAt(1, element);
   element = Capability::New(capability);
   msg.SetAt(2, element);
 
   uint8_t* data = NULL;
   MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
   writer.WriteMessage(msg);
 
   PortMap::PostMessage(new Message(main_port(), data, writer.BytesWritten(),
                                    Message::kOOBPriority));
 }
 
-
 class IsolateMessageHandler : public MessageHandler {
  public:
   explicit IsolateMessageHandler(Isolate* isolate);
   ~IsolateMessageHandler();
 
   const char* name() const;
   void MessageNotify(Message::Priority priority);
   MessageStatus HandleMessage(Message* message);
 #ifndef PRODUCT
   void NotifyPauseOnStart();
   void NotifyPauseOnExit();
 #endif  // !PRODUCT
 
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
 
  private:
   // A result of false indicates that the isolate should terminate the
   // processing of further events.
   RawError* HandleLibMessage(const Array& message);
 
   MessageStatus ProcessUnhandledException(const Error& result);
   Isolate* isolate_;
 };
 
-
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
     : isolate_(isolate) {}
 
-
 IsolateMessageHandler::~IsolateMessageHandler() {}
 
 const char* IsolateMessageHandler::name() const {
   return isolate_->name();
 }
 
-
 // Isolate library OOB messages are fixed sized arrays which have the
 // following format:
 // [ OOB dispatch, Isolate library dispatch, <message specific data> ]
 RawError* IsolateMessageHandler::HandleLibMessage(const Array& message) {
   if (message.Length() < 2) return Error::null();
   Zone* zone = T->zone();
   const Object& type = Object::Handle(zone, message.At(1));
   if (!type.IsSmi()) return Error::null();
   const intptr_t msg_type = Smi::Cast(type).Value();
   switch (msg_type) {
@@ skipping 161 matching lines @@
 #if defined(DEBUG)
     // Malformed OOB messages are silently ignored in release builds.
     default:
       UNREACHABLE();
       break;
 #endif  // defined(DEBUG)
   }
   return Error::null();
 }
 
-
 void IsolateMessageHandler::MessageNotify(Message::Priority priority) {
   if (priority >= Message::kOOBPriority) {
     // Handle out of band messages even if the mutator thread is busy.
     I->ScheduleMessageInterrupts();
   }
   Dart_MessageNotifyCallback callback = I->message_notify_callback();
   if (callback) {
     // Allow the embedder to handle message notification.
     (*callback)(Api::CastIsolate(I));
   }
 }
 
-
 MessageHandler::MessageStatus IsolateMessageHandler::HandleMessage(
     Message* message) {
   ASSERT(IsCurrentIsolate());
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   Zone* zone = stack_zone.GetZone();
   HandleScope handle_scope(thread);
 #ifndef PRODUCT
   TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
                             "HandleMessage");
@@ skipping 125 matching lines @@
     if (result.IsError()) {
       status = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
 #endif  // !PRODUCT
   return status;
 }
 
-
 #ifndef PRODUCT
 void IsolateMessageHandler::NotifyPauseOnStart() {
   if (!FLAG_support_service) {
     return;
   }
   if (Service::debug_stream.enabled() || FLAG_warn_on_pause_with_no_debugger) {
     StartIsolateScope start_isolate(I);
     StackZone zone(T);
     HandleScope handle_scope(T);
     ServiceEvent pause_event(I, ServiceEvent::kPauseStart);
     Service::HandleEvent(&pause_event);
   } else if (FLAG_trace_service) {
     OS::Print("vm-service: Dropping event of type PauseStart (%s)\n",
               I->name());
   }
 }
 
-
 void IsolateMessageHandler::NotifyPauseOnExit() {
   if (!FLAG_support_service) {
     return;
   }
   if (Service::debug_stream.enabled() || FLAG_warn_on_pause_with_no_debugger) {
     StartIsolateScope start_isolate(I);
     StackZone zone(T);
     HandleScope handle_scope(T);
     ServiceEvent pause_event(I, ServiceEvent::kPauseExit);
     Service::HandleEvent(&pause_event);
   } else if (FLAG_trace_service) {
     OS::Print("vm-service: Dropping event of type PauseExit (%s)\n", I->name());
   }
 }
 #endif  // !PRODUCT
 
-
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
-
 bool IsolateMessageHandler::IsCurrentIsolate() const {
   return (I == Isolate::Current());
 }
 
-
 static MessageHandler::MessageStatus StoreError(Thread* thread,
                                                 const Error& error) {
   thread->set_sticky_error(error);
   if (error.IsUnwindError()) {
     const UnwindError& unwind = UnwindError::Cast(error);
     if (!unwind.is_user_initiated()) {
       return MessageHandler::kShutdown;
     }
   }
   return MessageHandler::kError;
 }
 
-
 MessageHandler::MessageStatus IsolateMessageHandler::ProcessUnhandledException(
     const Error& result) {
   NoReloadScope no_reload_scope(T->isolate(), T);
   // Generate the error and stacktrace strings for the error message.
   String& exc_str = String::Handle(T->zone());
   String& stacktrace_str = String::Handle(T->zone());
   if (result.IsUnhandledException()) {
     Zone* zone = T->zone();
     const UnhandledException& uhe = UnhandledException::Cast(result);
     const Instance& exception = Instance::Handle(zone, uhe.exception());
@@ skipping 39 matching lines @@
             I->debugger()->PauseException(Instance::Handle(exception));
           }
         }
       }
       return kError;
     }
   }
   return kOK;
 }
 
-
 void Isolate::FlagsInitialize(Dart_IsolateFlags* api_flags) {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
 #define INIT_FROM_FLAG(name, isolate_flag, flag) api_flags->isolate_flag = flag;
   ISOLATE_FLAG_LIST(INIT_FROM_FLAG)
 #undef INIT_FROM_FLAG
 }
 
-
 void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
 #define INIT_FROM_FIELD(name, isolate_flag, flag)                              \
   api_flags->isolate_flag = name();
   ISOLATE_FLAG_LIST(INIT_FROM_FIELD)
 #undef INIT_FROM_FIELD
 }
 
-
 #if !defined(PRODUCT)
 void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
 #define SET_FROM_FLAG(name, isolate_flag, flag)                                \
   name##_ = api_flags.isolate_flag;
   ISOLATE_FLAG_LIST(SET_FROM_FLAG)
 #undef SET_FROM_FLAG
   // Leave others at defaults.
 }
 #endif  // !defined(PRODUCT)
 
-
 #if defined(DEBUG)
 // static
 void BaseIsolate::AssertCurrent(BaseIsolate* isolate) {
   ASSERT(isolate == Isolate::Current());
 }
 
 void BaseIsolate::AssertCurrentThreadIsMutator() const {
   ASSERT(Isolate::Current() == this);
   ASSERT(Thread::Current()->IsMutatorThread());
 }
@@ skipping 136 matching lines @@
   delete pause_loop_monitor_;
   pause_loop_monitor_ = NULL;
   delete field_list_mutex_;
   field_list_mutex_ = NULL;
   ASSERT(spawn_count_ == 0);
   delete spawn_count_monitor_;
   delete safepoint_handler_;
   delete thread_registry_;
 }
 
-
 void Isolate::InitOnce() {
   create_callback_ = NULL;
   isolates_list_monitor_ = new Monitor();
   ASSERT(isolates_list_monitor_ != NULL);
   EnableIsolateCreation();
 }
 
-
 Isolate* Isolate::Init(const char* name_prefix,
                        const Dart_IsolateFlags& api_flags,
                        bool is_vm_isolate) {
   Isolate* result = new Isolate(api_flags);
   ASSERT(result != NULL);
 
 // Initialize metrics.
 #define ISOLATE_METRIC_INIT(type, variable, name, unit)                        \
   result->metric_##variable##_.Init(result, name, NULL, Metric::unit);
   ISOLATE_METRIC_LIST(ISOLATE_METRIC_INIT);
@@ skipping 59 matching lines @@
   if (!AddIsolateToList(result)) {
     result->LowLevelShutdown();
     Thread::ExitIsolate();
     delete result;
     return NULL;
   }
 
   return result;
 }
 
-
 Thread* Isolate::mutator_thread() const {
   ASSERT(thread_registry() != NULL);
   return thread_registry()->mutator_thread();
 }
 
-
 void Isolate::SetupImagePage(const uint8_t* image_buffer, bool is_executable) {
   Image image(image_buffer);
   heap_->SetupImagePage(image.object_start(), image.object_size(),
                         is_executable);
 }
 
-
 void Isolate::ScheduleMessageInterrupts() {
   // We take the threads lock here to ensure that the mutator thread does not
   // exit the isolate while we are trying to schedule interrupts on it.
   MonitorLocker ml(threads_lock());
   Thread* mthread = mutator_thread();
   if (mthread != NULL) {
     mthread->ScheduleInterrupts(Thread::kMessageInterrupt);
   }
 }
 
-
 void Isolate::set_debugger_name(const char* name) {
   free(debugger_name_);
   debugger_name_ = strdup(name);
 }
 
-
 int64_t Isolate::UptimeMicros() const {
   return OS::GetCurrentMonotonicMicros() - start_time_micros_;
 }
 
-
 bool Isolate::IsPaused() const {
   return (debugger_ != NULL) && (debugger_->PauseEvent() != NULL);
 }
 
-
 RawError* Isolate::PausePostRequest() {
   if (!FLAG_support_debugger) {
     return Error::null();
   }
   if (debugger_ == NULL) {
     return Error::null();
   }
   ASSERT(!IsPaused());
   const Error& error = Error::Handle(debugger_->PausePostRequest());
   if (!error.IsNull()) {
     if (Thread::Current()->top_exit_frame_info() == 0) {
       return error.raw();
     } else {
       Exceptions::PropagateError(error);
       UNREACHABLE();
     }
   }
   return Error::null();
 }
 
-
 void Isolate::BuildName(const char* name_prefix) {
   ASSERT(name_ == NULL);
   if (name_prefix == NULL) {
     name_prefix = "isolate";
   }
   set_debugger_name(name_prefix);
   if (ServiceIsolate::NameEquals(name_prefix)) {
     name_ = strdup(name_prefix);
     return;
   }
   name_ = OS::SCreate(NULL, "%s-%" Pd64 "", name_prefix, main_port());
 }
 
-
 void Isolate::DoneLoading() {
   GrowableObjectArray& libs =
       GrowableObjectArray::Handle(current_zone(), object_store()->libraries());
   Library& lib = Library::Handle(current_zone());
   intptr_t num_libs = libs.Length();
   for (intptr_t i = 0; i < num_libs; i++) {
     lib ^= libs.At(i);
     // If this library was loaded with Dart_LoadLibrary, it was marked
     // as 'load in progres'. Set the status to 'loaded'.
     if (lib.LoadInProgress()) {
       lib.SetLoaded();
     }
   }
   TokenStream::CloseSharedTokenList(this);
 }
 
-
 bool Isolate::CanReload() const {
 #ifndef PRODUCT
   return !ServiceIsolate::IsServiceIsolateDescendant(this) && is_runnable() &&
          !IsReloading() &&
          (AtomicOperations::LoadRelaxed(&no_reload_scope_depth_) == 0) &&
          IsolateCreationEnabled();
 #else
   return false;
 #endif
 }
 
-
 #ifndef PRODUCT
 bool Isolate::ReloadSources(JSONStream* js,
                             bool force_reload,
                             const char* root_script_url,
                             const char* packages_url,
                             bool dont_delete_reload_context) {
   ASSERT(!IsReloading());
   has_attempted_reload_ = true;
   reload_context_ = new IsolateReloadContext(this, js);
   reload_context_->Reload(force_reload, root_script_url, packages_url);
   bool success = !reload_context_->reload_aborted();
   if (!dont_delete_reload_context) {
     DeleteReloadContext();
   }
   return success;
 }
 
-
 void Isolate::DeleteReloadContext() {
   // Another thread may be in the middle of GetClassForHeapWalkAt.
   Thread* thread = Thread::Current();
   SafepointOperationScope safepoint_scope(thread);
 
   delete reload_context_;
   reload_context_ = NULL;
 }
 #endif  // !PRODUCT
 
-
 void Isolate::DoneFinalizing() {
 #if !defined(PRODUCT)
   if (IsReloading()) {
     reload_context_->FinalizeLoading();
   }
 #endif  // !defined(PRODUCT)
 }
 
-
 bool Isolate::MakeRunnable() {
   ASSERT(Isolate::Current() == NULL);
 
   MutexLocker ml(mutex_);
   // Check if we are in a valid state to make the isolate runnable.
   if (is_runnable() == true) {
     return false;  // Already runnable.
   }
   // Set the isolate as runnable and if we are being spawned schedule
   // isolate on thread pool for execution.
@@ skipping 35 matching lines @@
       StartIsolateScope scope(this);
       heap()->CollectAllGarbage();
     }
     int64_t heap_size = (heap()->UsedInWords(Heap::kNew) * kWordSize) +
                         (heap()->UsedInWords(Heap::kOld) * kWordSize);
     GetRunnableHeapSizeMetric()->set_value(heap_size);
   }
   return true;
 }
 
-
 bool Isolate::VerifyPauseCapability(const Object& capability) const {
   return !capability.IsNull() && capability.IsCapability() &&
          (pause_capability() == Capability::Cast(capability).Id());
 }
 
-
 bool Isolate::VerifyTerminateCapability(const Object& capability) const {
   return !capability.IsNull() && capability.IsCapability() &&
          (terminate_capability() == Capability::Cast(capability).Id());
 }
 
-
 bool Isolate::AddResumeCapability(const Capability& capability) {
   // Ensure a limit for the number of resume capabilities remembered.
   static const intptr_t kMaxResumeCapabilities = kSmiMax / (6 * kWordSize);
 
   const GrowableObjectArray& caps = GrowableObjectArray::Handle(
       current_zone(), object_store()->resume_capabilities());
   Capability& current = Capability::Handle(current_zone());
   intptr_t insertion_index = -1;
   for (intptr_t i = 0; i < caps.Length(); i++) {
     current ^= caps.At(i);
@@ skipping 12 matching lines @@
       // run out of memory beforehand.
       return false;
     }
     caps.Add(capability);
   } else {
     caps.SetAt(insertion_index, capability);
   }
   return true;
 }
 
-
 bool Isolate::RemoveResumeCapability(const Capability& capability) {
   const GrowableObjectArray& caps = GrowableObjectArray::Handle(
       current_zone(), object_store()->resume_capabilities());
   Capability& current = Capability::Handle(current_zone());
   for (intptr_t i = 0; i < caps.Length(); i++) {
     current ^= caps.At(i);
     if (!current.IsNull() && (current.Id() == capability.Id())) {
       // Remove the matching capability from the list.
       current = Capability::null();
       caps.SetAt(i, current);
       return true;
     }
   }
   return false;
 }
 
-
 // TODO(iposva): Remove duplicated code and start using some hash based
 // structure instead of these linear lookups.
 void Isolate::AddExitListener(const SendPort& listener,
                               const Instance& response) {
   // Ensure a limit for the number of listeners remembered.
   static const intptr_t kMaxListeners = kSmiMax / (12 * kWordSize);
 
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       current_zone(), object_store()->exit_listeners());
   SendPort& current = SendPort::Handle(current_zone());
@@ skipping 17 matching lines @@
       return;
     }
     listeners.Add(listener);
     listeners.Add(response);
   } else {
     listeners.SetAt(insertion_index, listener);
     listeners.SetAt(insertion_index + 1, response);
   }
 }
 
-
 void Isolate::RemoveExitListener(const SendPort& listener) {
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       current_zone(), object_store()->exit_listeners());
   SendPort& current = SendPort::Handle(current_zone());
   for (intptr_t i = 0; i < listeners.Length(); i += 2) {
     current ^= listeners.At(i);
     if (!current.IsNull() && (current.Id() == listener.Id())) {
       // Remove the matching listener from the list.
       current = SendPort::null();
       listeners.SetAt(i, current);
       listeners.SetAt(i + 1, Object::null_instance());
       return;
     }
   }
 }
 
-
 void Isolate::NotifyExitListeners() {
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       current_zone(), this->object_store()->exit_listeners());
   if (listeners.IsNull()) return;
 
   SendPort& listener = SendPort::Handle(current_zone());
   Instance& response = Instance::Handle(current_zone());
   for (intptr_t i = 0; i < listeners.Length(); i += 2) {
     listener ^= listeners.At(i);
     if (!listener.IsNull()) {
       Dart_Port port_id = listener.Id();
       response ^= listeners.At(i + 1);
       PortMap::PostMessage(SerializeMessage(port_id, response));
     }
   }
 }
 
-
 void Isolate::AddErrorListener(const SendPort& listener) {
   // Ensure a limit for the number of listeners remembered.
   static const intptr_t kMaxListeners = kSmiMax / (6 * kWordSize);
 
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       current_zone(), object_store()->error_listeners());
   SendPort& current = SendPort::Handle(current_zone());
   intptr_t insertion_index = -1;
   for (intptr_t i = 0; i < listeners.Length(); i++) {
     current ^= listeners.At(i);
@@ skipping 11 matching lines @@
       // listeners are ignored. In practice will never happen as we will
       // run out of memory beforehand.
       return;
     }
     listeners.Add(listener);
   } else {
     listeners.SetAt(insertion_index, listener);
   }
 }
 
-
 void Isolate::RemoveErrorListener(const SendPort& listener) {
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       current_zone(), object_store()->error_listeners());
   SendPort& current = SendPort::Handle(current_zone());
   for (intptr_t i = 0; i < listeners.Length(); i++) {
     current ^= listeners.At(i);
     if (!current.IsNull() && (current.Id() == listener.Id())) {
       // Remove the matching listener from the list.
       current = SendPort::null();
       listeners.SetAt(i, current);
       return;
     }
   }
 }
 
-
 bool Isolate::NotifyErrorListeners(const String& msg,
                                    const String& stacktrace) {
   const GrowableObjectArray& listeners = GrowableObjectArray::Handle(
       current_zone(), this->object_store()->error_listeners());
   if (listeners.IsNull()) return false;
 
   const Array& arr = Array::Handle(current_zone(), Array::New(2));
   arr.SetAt(0, msg);
   arr.SetAt(1, stacktrace);
   SendPort& listener = SendPort::Handle(current_zone());
   for (intptr_t i = 0; i < listeners.Length(); i++) {
     listener ^= listeners.At(i);
     if (!listener.IsNull()) {
       Dart_Port port_id = listener.Id();
       PortMap::PostMessage(SerializeMessage(port_id, arr));
     }
   }
   return listeners.Length() > 0;
 }
 
-
 static MessageHandler::MessageStatus RunIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   IsolateSpawnState* state = NULL;
   {
     // TODO(turnidge): Is this locking required here at all anymore?
     MutexLocker ml(isolate->mutex());
     state = isolate->spawn_state();
   }
   {
     StartIsolateScope start_scope(isolate);
@@ skipping 11 matching lines @@
       isolate->AddExitListener(listener, Instance::null_instance());
     }
     if (state->on_error_port() != ILLEGAL_PORT) {
       const SendPort& listener =
           SendPort::Handle(SendPort::New(state->on_error_port()));
       isolate->AddErrorListener(listener);
     }
 
     // Switch back to spawning isolate.
 
-
     if (!ClassFinalizer::ProcessPendingClasses()) {
 // Error is in sticky error already.
 #if defined(DEBUG)
       const Error& error = Error::Handle(thread->sticky_error());
       ASSERT(!error.IsUnwindError());
 #endif
       return MessageHandler::kError;
     }
 
     Object& result = Object::Handle();
@@ skipping 54 matching lines @@
     ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
 
     result = DartEntry::InvokeFunction(entry_point, args);
     if (result.IsError()) {
       return StoreError(thread, Error::Cast(result));
     }
   }
   return MessageHandler::kOK;
 }
 
-
 static void ShutdownIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   // We must wait for any outstanding spawn calls to complete before
   // running the shutdown callback.
   isolate->WaitForOutstandingSpawns();
   {
     // Print the error if there is one.  This may execute dart code to
     // print the exception object, so we need to use a StartIsolateScope.
     StartIsolateScope start_scope(isolate);
     Thread* thread = Thread::Current();
@@ skipping 14 matching lines @@
     const Error& error = Error::Handle(thread->sticky_error());
     if (!error.IsNull() && !error.IsUnwindError()) {
       OS::PrintErr("in ShutdownIsolate: %s\n", error.ToErrorCString());
     }
     Dart::RunShutdownCallback();
   }
   // Shut the isolate down.
   Dart::ShutdownIsolate(isolate);
 }
 
-
 void Isolate::SetStickyError(RawError* sticky_error) {
   ASSERT(
       ((sticky_error_ == Error::null()) || (sticky_error == Error::null())) &&
       (sticky_error != sticky_error_));
   sticky_error_ = sticky_error;
 }
 
-
 void Isolate::Run() {
   message_handler()->Run(Dart::thread_pool(), RunIsolate, ShutdownIsolate,
                          reinterpret_cast<uword>(this));
 }
 
-
 void Isolate::AddClosureFunction(const Function& function) const {
   ASSERT(!Compiler::IsBackgroundCompilation());
   GrowableObjectArray& closures =
       GrowableObjectArray::Handle(object_store()->closure_functions());
   ASSERT(!closures.IsNull());
   ASSERT(function.IsNonImplicitClosureFunction());
   closures.Add(function, Heap::kOld);
 }
 
-
 // If the linear lookup turns out to be too expensive, the list
 // of closures could be maintained in a hash map, with the key
 // being the token position of the closure. There are almost no
 // collisions with this simple hash value. However, iterating over
 // all closure functions becomes more difficult, especially when
 // the list/map changes while iterating over it.
 RawFunction* Isolate::LookupClosureFunction(const Function& parent,
                                             TokenPosition token_pos) const {
   const GrowableObjectArray& closures =
       GrowableObjectArray::Handle(object_store()->closure_functions());
   ASSERT(!closures.IsNull());
   Function& closure = Function::Handle();
   intptr_t num_closures = closures.Length();
   for (intptr_t i = 0; i < num_closures; i++) {
     closure ^= closures.At(i);
     if ((closure.token_pos() == token_pos) &&
         (closure.parent_function() == parent.raw())) {
       return closure.raw();
     }
   }
   return Function::null();
 }
 
-
 intptr_t Isolate::FindClosureIndex(const Function& needle) const {
   const GrowableObjectArray& closures_array =
       GrowableObjectArray::Handle(object_store()->closure_functions());
   intptr_t num_closures = closures_array.Length();
   for (intptr_t i = 0; i < num_closures; i++) {
     if (closures_array.At(i) == needle.raw()) {
       return i;
     }
   }
   return -1;
 }
 
-
 RawFunction* Isolate::ClosureFunctionFromIndex(intptr_t idx) const {
   const GrowableObjectArray& closures_array =
       GrowableObjectArray::Handle(object_store()->closure_functions());
   if ((idx < 0) || (idx >= closures_array.Length())) {
     return Function::null();
   }
   return Function::RawCast(closures_array.At(idx));
 }
 
-
 class FinalizeWeakPersistentHandlesVisitor : public HandleVisitor {
  public:
   FinalizeWeakPersistentHandlesVisitor() : HandleVisitor(Thread::Current()) {}
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     handle->UpdateUnreachable(thread()->isolate());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FinalizeWeakPersistentHandlesVisitor);
 };
 
-
 void Isolate::LowLevelShutdown() {
   // Ensure we have a zone and handle scope so that we can call VM functions,
   // but we no longer allocate new heap objects.
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   HandleScope handle_scope(thread);
   NoSafepointScope no_safepoint_scope;
 
   // Notify exit listeners that this isolate is shutting down.
   if (object_store() != NULL) {
     const Error& error = Error::Handle(thread->sticky_error());
     if (error.IsNull() || !error.IsUnwindError() ||
         UnwindError::Cast(error).is_user_initiated()) {
       NotifyExitListeners();
     }
   }
 
   // Clean up debugger resources.
   if (FLAG_support_debugger) {
     debugger()->Shutdown();
   }
 
-
   // Close all the ports owned by this isolate.
   PortMap::ClosePorts(message_handler());
 
   // Fail fast if anybody tries to post any more messages to this isolate.
   delete message_handler();
   set_message_handler(NULL);
   if (FLAG_support_timeline) {
     // Before analyzing the isolate's timeline blocks- reclaim all cached
     // blocks.
     Timeline::ReclaimCachedBlocksFromThreads();
@@ skipping 28 matching lines @@
     LogBlock lb;
     OS::PrintErr("Printing metrics for %s\n", name());
 #define ISOLATE_METRIC_PRINT(type, variable, name, unit)                       \
   OS::PrintErr("%s\n", metric_##variable##_.ToString());
     ISOLATE_METRIC_LIST(ISOLATE_METRIC_PRINT)
 #undef ISOLATE_METRIC_PRINT
     OS::PrintErr("\n");
   }
 }
 
-
 void Isolate::StopBackgroundCompiler() {
   // Wait until all background compilation has finished.
   if (background_compiler_ != NULL) {
     BackgroundCompiler::Stop(this);
   }
 }
 
-
 void Isolate::MaybeIncreaseReloadEveryNStackOverflowChecks() {
   if (FLAG_reload_every_back_off) {
     if (reload_every_n_stack_overflow_checks_ < 5000) {
       reload_every_n_stack_overflow_checks_ += 99;
     } else {
       reload_every_n_stack_overflow_checks_ *= 2;
     }
     // Cap the value.
     if (reload_every_n_stack_overflow_checks_ > 1000000) {
       reload_every_n_stack_overflow_checks_ = 1000000;
     }
   }
 }
 
-
 void Isolate::Shutdown() {
   ASSERT(this == Isolate::Current());
   StopBackgroundCompiler();
 
 #if defined(DEBUG)
   if (heap_ != NULL && FLAG_verify_on_transition) {
     // The VM isolate keeps all objects marked.
     heap_->Verify(this == Dart::vm_isolate() ? kRequireMarked : kForbidMarked);
   }
 #endif  // DEBUG
@@ skipping 55 matching lines @@
   // TODO(5411455): For now just make sure there are no current isolates
   // as we are shutting down the isolate.
   Thread::ExitIsolate();
 
   Dart_IsolateCleanupCallback cleanup = Isolate::CleanupCallback();
   if (cleanup != NULL) {
     cleanup(init_callback_data());
   }
 }
 
-
 Dart_IsolateCreateCallback Isolate::create_callback_ = NULL;
 Dart_IsolateShutdownCallback Isolate::shutdown_callback_ = NULL;
 Dart_IsolateCleanupCallback Isolate::cleanup_callback_ = NULL;
 
 Monitor* Isolate::isolates_list_monitor_ = NULL;
 Isolate* Isolate::isolates_list_head_ = NULL;
 bool Isolate::creation_enabled_ = false;
 
 void Isolate::IterateObjectPointers(ObjectPointerVisitor* visitor,
                                     bool validate_frames) {
   HeapIterationScope heap_iteration_scope;
   VisitObjectPointers(visitor, validate_frames);
 }
 
-
 void Isolate::IterateStackPointers(ObjectPointerVisitor* visitor,
                                    bool validate_frames) {
   HeapIterationScope heap_iteration_scope;
   VisitStackPointers(visitor, validate_frames);
 }
 
-
 void Isolate::VisitObjectPointers(ObjectPointerVisitor* visitor,
                                   bool validate_frames) {
   ASSERT(visitor != NULL);
 
   // Visit objects in the object store.
   object_store()->VisitObjectPointers(visitor);
 
   // Visit objects in the class table.
   class_table()->VisitObjectPointers(visitor);
 
@@ skipping 56 matching lines @@
 #if !defined(DART_PRECOMPILED_RUNTIME)
   // Visit objects that are being used for deoptimization.
   if (deopt_context() != NULL) {
     deopt_context()->VisitObjectPointers(visitor);
   }
 #endif
 
   VisitStackPointers(visitor, validate_frames);
 }
 
-
 void Isolate::VisitStackPointers(ObjectPointerVisitor* visitor,
                                  bool validate_frames) {
   // Visit objects in all threads (e.g., Dart stack, handles in zones).
   thread_registry()->VisitObjectPointers(visitor, validate_frames);
 }
 
-
 void Isolate::VisitWeakPersistentHandles(HandleVisitor* visitor) {
   if (api_state() != NULL) {
     api_state()->VisitWeakHandles(visitor);
   }
 }
 
-
 void Isolate::PrepareForGC() {
   thread_registry()->PrepareForGC();
 }
 
-
 RawClass* Isolate::GetClassForHeapWalkAt(intptr_t cid) {
   RawClass* raw_class = NULL;
 #ifndef PRODUCT
   if (IsReloading()) {
     raw_class = reload_context()->GetClassForHeapWalkAt(cid);
   } else {
     raw_class = class_table()->At(cid);
   }
 #else
   raw_class = class_table()->At(cid);
 #endif  // !PRODUCT
   ASSERT(raw_class != NULL);
   ASSERT(remapping_cids_ || raw_class->ptr()->id_ == cid);
   return raw_class;
 }
 
-
 void Isolate::AddPendingDeopt(uword fp, uword pc) {
   // GrowableArray::Add is not atomic and may be interrupt by a profiler
   // stack walk.
   MallocGrowableArray<PendingLazyDeopt>* old_pending_deopts = pending_deopts_;
   MallocGrowableArray<PendingLazyDeopt>* new_pending_deopts =
       new MallocGrowableArray<PendingLazyDeopt>(old_pending_deopts->length() +
                                                 1);
   for (intptr_t i = 0; i < old_pending_deopts->length(); i++) {
     ASSERT((*old_pending_deopts)[i].fp() != fp);
     new_pending_deopts->Add((*old_pending_deopts)[i]);
   }
   PendingLazyDeopt deopt(fp, pc);
   new_pending_deopts->Add(deopt);
 
   pending_deopts_ = new_pending_deopts;
   delete old_pending_deopts;
 }
 
-
 uword Isolate::FindPendingDeopt(uword fp) const {
   for (intptr_t i = 0; i < pending_deopts_->length(); i++) {
     if ((*pending_deopts_)[i].fp() == fp) {
       return (*pending_deopts_)[i].pc();
     }
   }
   FATAL("Missing pending deopt entry");
   return 0;
 }
 
-
 void Isolate::ClearPendingDeoptsAtOrBelow(uword fp) const {
   for (intptr_t i = pending_deopts_->length() - 1; i >= 0; i--) {
     if ((*pending_deopts_)[i].fp() <= fp) {
       pending_deopts_->RemoveAt(i);
     }
   }
 }
 
-
 #ifndef PRODUCT
 static const char* ExceptionPauseInfoToServiceEnum(Dart_ExceptionPauseInfo pi) {
   switch (pi) {
     case kPauseOnAllExceptions:
       return "All";
     case kNoPauseOnExceptions:
       return "None";
     case kPauseOnUnhandledExceptions:
       return "Unhandled";
     default:
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
-
 void Isolate::PrintJSON(JSONStream* stream, bool ref) {
   if (!FLAG_support_service) {
     return;
   }
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", (ref ? "@Isolate" : "Isolate"));
   jsobj.AddFixedServiceId(ISOLATE_SERVICE_ID_FORMAT_STRING,
                           static_cast<int64_t>(main_port()));
 
   jsobj.AddProperty("name", debugger_name());
@@ skipping 114 matching lines @@
         handler_name ^= handlers.At(i + kRegisteredNameIndex);
         extensions.AddValue(handler_name.ToCString());
       }
     }
   }
 
   jsobj.AddProperty("_threads", thread_registry_);
 }
 #endif
 
-
 void Isolate::set_tag_table(const GrowableObjectArray& value) {
   tag_table_ = value.raw();
 }
 
-
 void Isolate::set_current_tag(const UserTag& tag) {
   uword user_tag = tag.tag();
   ASSERT(user_tag < kUwordMax);
   set_user_tag(user_tag);
   current_tag_ = tag.raw();
 }
 
-
 void Isolate::set_default_tag(const UserTag& tag) {
   default_tag_ = tag.raw();
 }
 
 void Isolate::set_ic_miss_code(const Code& code) {
   ic_miss_code_ = code.raw();
 }
 
-
 void Isolate::set_deoptimized_code_array(const GrowableObjectArray& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
   deoptimized_code_array_ = value.raw();
 }
 
-
 void Isolate::TrackDeoptimizedCode(const Code& code) {
   ASSERT(!code.IsNull());
   const GrowableObjectArray& deoptimized_code =
       GrowableObjectArray::Handle(deoptimized_code_array());
   if (deoptimized_code.IsNull()) {
     // Not tracking deoptimized code.
     return;
   }
   // TODO(johnmccutchan): Scan this array and the isolate's profile before
   // old space GC and remove the keep_code flag.
   deoptimized_code.Add(code);
 }
 
-
 void Isolate::clear_sticky_error() {
   sticky_error_ = Error::null();
 }
 
-
 void Isolate::set_pending_service_extension_calls(
     const GrowableObjectArray& value) {
   pending_service_extension_calls_ = value.raw();
 }
 
-
 void Isolate::set_registered_service_extension_handlers(
     const GrowableObjectArray& value) {
   registered_service_extension_handlers_ = value.raw();
 }
 
-
 void Isolate::AddDeoptimizingBoxedField(const Field& field) {
   ASSERT(Compiler::IsBackgroundCompilation());
   ASSERT(!field.IsOriginal());
   // The enclosed code allocates objects and can potentially trigger a GC,
   // ensure that we account for safepoints when grabbing the lock.
   SafepointMutexLocker ml(field_list_mutex_);
   if (boxed_field_list_ == GrowableObjectArray::null()) {
     boxed_field_list_ = GrowableObjectArray::New(Heap::kOld);
   }
   const GrowableObjectArray& array =
       GrowableObjectArray::Handle(boxed_field_list_);
   array.Add(Field::Handle(field.Original()), Heap::kOld);
 }
 
-
 RawField* Isolate::GetDeoptimizingBoxedField() {
   ASSERT(Thread::Current()->IsMutatorThread());
   SafepointMutexLocker ml(field_list_mutex_);
   if (boxed_field_list_ == GrowableObjectArray::null()) {
     return Field::null();
   }
   const GrowableObjectArray& array =
       GrowableObjectArray::Handle(boxed_field_list_);
   if (array.Length() == 0) {
     return Field::null();
   }
   return Field::RawCast(array.RemoveLast());
 }
 
-
 #ifndef PRODUCT
 RawObject* Isolate::InvokePendingServiceExtensionCalls() {
   if (!FLAG_support_service) {
     return Object::null();
   }
   GrowableObjectArray& calls =
       GrowableObjectArray::Handle(GetAndClearPendingServiceExtensionCalls());
   if (calls.IsNull()) {
     return Object::null();
   }
@@ skipping 57 matching lines @@
     result = DartLibraryCalls::DrainMicrotaskQueue();
     // Propagate the error.
     if (result.IsError()) {
       // Remaining service extension calls are dropped.
       return result.raw();
     }
   }
   return Object::null();
 }
 
-
 RawGrowableObjectArray* Isolate::GetAndClearPendingServiceExtensionCalls() {
   RawGrowableObjectArray* r = pending_service_extension_calls_;
   pending_service_extension_calls_ = GrowableObjectArray::null();
   return r;
 }
 
-
 void Isolate::AppendServiceExtensionCall(const Instance& closure,
                                          const String& method_name,
                                          const Array& parameter_keys,
                                          const Array& parameter_values,
                                          const Instance& reply_port,
                                          const Instance& id) {
   if (FLAG_trace_service) {
     OS::Print("[+%" Pd64 "ms] Isolate %s ENQUEUING request for extension %s\n",
               Dart::UptimeMillis(), name(), method_name.ToCString());
   }
@@ skipping 11 matching lines @@
   ASSERT(kPendingKeysIndex == 2);
   calls.Add(parameter_keys);
   ASSERT(kPendingValuesIndex == 3);
   calls.Add(parameter_values);
   ASSERT(kPendingReplyPortIndex == 4);
   calls.Add(reply_port);
   ASSERT(kPendingIdIndex == 5);
   calls.Add(id);
 }
 
-
 // This function is written in C++ and not Dart because we must do this
 // operation atomically in the face of random OOB messages. Do not port
 // to Dart code unless you can ensure that the operations will can be
 // done atomically.
 void Isolate::RegisterServiceExtensionHandler(const String& name,
                                               const Instance& closure) {
   if (!FLAG_support_service) {
     return;
   }
   GrowableObjectArray& handlers =
@@ skipping 15 matching lines @@
   ASSERT(kRegisteredHandlerIndex == 1);
   handlers.Add(closure, Heap::kOld);
   {
     // Fire off an event.
     ServiceEvent event(this, ServiceEvent::kServiceExtensionAdded);
     event.set_extension_rpc(&name);
     Service::HandleEvent(&event);
   }
 }
 
-
 // This function is written in C++ and not Dart because we must do this
 // operation atomically in the face of random OOB messages. Do not port
 // to Dart code unless you can ensure that the operations will can be
 // done atomically.
 RawInstance* Isolate::LookupServiceExtensionHandler(const String& name) {
   if (!FLAG_support_service) {
     return Instance::null();
   }
   const GrowableObjectArray& handlers =
       GrowableObjectArray::Handle(registered_service_extension_handlers());
   if (handlers.IsNull()) {
     return Instance::null();
   }
   String& handler_name = String::Handle();
   for (intptr_t i = 0; i < handlers.Length(); i += kRegisteredEntrySize) {
     handler_name ^= handlers.At(i + kRegisteredNameIndex);
     ASSERT(!handler_name.IsNull());
     if (handler_name.Equals(name)) {
       return Instance::RawCast(handlers.At(i + kRegisteredHandlerIndex));
     }
   }
   return Instance::null();
 }
 #endif  // !PRODUCT
 
-
 void Isolate::WakePauseEventHandler(Dart_Isolate isolate) {
   Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   MonitorLocker ml(iso->pause_loop_monitor_);
   ml.Notify();
 }
 
-
 void Isolate::PauseEventHandler() {
   // We are stealing a pause event (like a breakpoint) from the
   // embedder.  We don't know what kind of thread we are on -- it
   // could be from our thread pool or it could be a thread from the
   // embedder.  Sit on the current thread handling service events
   // until we are told to resume.
   if (pause_loop_monitor_ == NULL) {
     pause_loop_monitor_ = new Monitor();
   }
   Dart_EnterScope();
@@ skipping 29 matching lines @@
     }
 
     // Wait for more service messages.
     Monitor::WaitResult res = ml.Wait();
     ASSERT(res == Monitor::kNotified);
   }
   set_message_notify_callback(saved_notify_callback);
   Dart_ExitScope();
 }
 
-
 void Isolate::VisitIsolates(IsolateVisitor* visitor) {
   if (visitor == NULL) {
     return;
   }
   // The visitor could potentially run code that could safepoint so use
   // SafepointMonitorLocker to ensure the lock has safepoint checks.
   SafepointMonitorLocker ml(isolates_list_monitor_);
   Isolate* current = isolates_list_head_;
   while (current) {
     visitor->VisitIsolate(current);
     current = current->next_;
   }
 }
 
-
 intptr_t Isolate::IsolateListLength() {
   MonitorLocker ml(isolates_list_monitor_);
   intptr_t count = 0;
   Isolate* current = isolates_list_head_;
   while (current != NULL) {
     count++;
     current = current->next_;
   }
   return count;
 }
 
-
 bool Isolate::AddIsolateToList(Isolate* isolate) {
   MonitorLocker ml(isolates_list_monitor_);
   if (!creation_enabled_) {
     return false;
   }
   ASSERT(isolate != NULL);
   ASSERT(isolate->next_ == NULL);
   isolate->next_ = isolates_list_head_;
   isolates_list_head_ = isolate;
   return true;
 }
 
-
 void Isolate::RemoveIsolateFromList(Isolate* isolate) {
   MonitorLocker ml(isolates_list_monitor_);
   ASSERT(isolate != NULL);
   if (isolate == isolates_list_head_) {
     isolates_list_head_ = isolate->next_;
     if (!creation_enabled_) {
       ml.Notify();
     }
     return;
   }
   Isolate* previous = NULL;
   Isolate* current = isolates_list_head_;
   while (current) {
     if (current == isolate) {
       ASSERT(previous != NULL);
       previous->next_ = current->next_;
       if (!creation_enabled_) {
         ml.Notify();
       }
       return;
     }
     previous = current;
     current = current->next_;
   }
   // If we are shutting down the VM, the isolate may not be in the list.
   ASSERT(!creation_enabled_);
 }
 
-
 void Isolate::DisableIsolateCreation() {
   MonitorLocker ml(isolates_list_monitor_);
   creation_enabled_ = false;
 }
 
-
 void Isolate::EnableIsolateCreation() {
   MonitorLocker ml(isolates_list_monitor_);
   creation_enabled_ = true;
 }
 
-
 bool Isolate::IsolateCreationEnabled() {
   MonitorLocker ml(isolates_list_monitor_);
   return creation_enabled_;
 }
 
-
 void Isolate::KillLocked(LibMsgId msg_id) {
   Dart_CObject kill_msg;
   Dart_CObject* list_values[4];
   kill_msg.type = Dart_CObject_kArray;
   kill_msg.value.as_array.length = 4;
   kill_msg.value.as_array.values = list_values;
 
   Dart_CObject oob;
   oob.type = Dart_CObject_kInt32;
   oob.value.as_int32 = Message::kIsolateLibOOBMsg;
@@ skipping 20 matching lines @@
     bool success = writer.WriteCMessage(&kill_msg);
     ASSERT(success);
 
     // Post the message at the given port.
     success = PortMap::PostMessage(new Message(
         main_port(), buffer, writer.BytesWritten(), Message::kOOBPriority));
     ASSERT(success);
   }
 }
 
-
 class IsolateKillerVisitor : public IsolateVisitor {
  public:
   explicit IsolateKillerVisitor(Isolate::LibMsgId msg_id)
       : target_(NULL), msg_id_(msg_id) {}
 
   IsolateKillerVisitor(Isolate* isolate, Isolate::LibMsgId msg_id)
       : target_(isolate), msg_id_(msg_id) {
     ASSERT(isolate != Dart::vm_isolate());
   }
 
@@ skipping 11 matching lines @@
     // If a target_ is specified, then only kill the target_.
     // Otherwise, don't kill the service isolate or vm isolate.
     return (((target_ != NULL) && (isolate == target_)) ||
             ((target_ == NULL) && !IsVMInternalIsolate(isolate)));
   }
 
   Isolate* target_;
   Isolate::LibMsgId msg_id_;
 };
 
-
 void Isolate::KillAllIsolates(LibMsgId msg_id) {
   IsolateKillerVisitor visitor(msg_id);
   VisitIsolates(&visitor);
 }
 
-
 void Isolate::KillIfExists(Isolate* isolate, LibMsgId msg_id) {
   IsolateKillerVisitor visitor(isolate, msg_id);
   VisitIsolates(&visitor);
 }
 
-
 void Isolate::IncrementSpawnCount() {
   MonitorLocker ml(spawn_count_monitor_);
   spawn_count_++;
 }
 
-
 void Isolate::WaitForOutstandingSpawns() {
   MonitorLocker ml(spawn_count_monitor_);
   while (spawn_count_ > 0) {
     ml.Wait();
   }
 }
 
-
 Monitor* Isolate::threads_lock() const {
   return thread_registry_->threads_lock();
 }
 
-
 Thread* Isolate::ScheduleThread(bool is_mutator, bool bypass_safepoint) {
   // Schedule the thread into the isolate by associating
   // a 'Thread' structure with it (this is done while we are holding
   // the thread registry lock).
   Thread* thread = NULL;
   OSThread* os_thread = OSThread::Current();
   if (os_thread != NULL) {
     // We are about to associate the thread with an isolate and it would
     // not be possible to correctly track no_safepoint_scope_depth for the
     // thread in the constructor/destructor of MonitorLocker,
@@ skipping 31 matching lines @@
     os_thread->set_thread(thread);
     if (is_mutator) {
       mutator_thread_ = thread;
     }
     Thread::SetCurrent(thread);
     os_thread->EnableThreadInterrupts();
   }
   return thread;
 }
 
-
 void Isolate::UnscheduleThread(Thread* thread,
                                bool is_mutator,
                                bool bypass_safepoint) {
   // Disassociate the 'Thread' structure and unschedule the thread
   // from this isolate.
   // We are disassociating the thread from an isolate and it would
   // not be possible to correctly track no_safepoint_scope_depth for the
   // thread in the constructor/destructor of MonitorLocker,
   // so we create a MonitorLocker object which does not do any
   // no_safepoint_scope_depth increments/decrements.
@@ skipping 24 matching lines @@
   thread->heap_ = NULL;
   thread->set_os_thread(NULL);
   thread->set_execution_state(Thread::kThreadInNative);
   thread->set_safepoint_state(Thread::SetAtSafepoint(true, 0));
   thread->clear_pending_functions();
   ASSERT(thread->no_safepoint_scope_depth() == 0);
   // Return thread structure.
   thread_registry()->ReturnThreadLocked(is_mutator, thread);
 }
 
-
 static RawInstance* DeserializeObject(Thread* thread,
                                       uint8_t* obj_data,
                                       intptr_t obj_len) {
   if (obj_data == NULL) {
     return Instance::null();
   }
   MessageSnapshotReader reader(obj_data, obj_len, thread);
   Zone* zone = thread->zone();
   const Object& obj = Object::Handle(zone, reader.ReadObject());
   ASSERT(!obj.IsError());
   Instance& instance = Instance::Handle(zone);
   instance ^= obj.raw();  // Can't use Instance::Cast because may be null.
   return instance.raw();
 }
 
-
 static const char* NewConstChar(const char* chars) {
   size_t len = strlen(chars);
   char* mem = new char[len + 1];
   memmove(mem, chars, len + 1);
   return mem;
 }
 
-
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      Dart_Port origin_id,
                                      void* init_data,
                                      const char* script_url,
                                      const Function& func,
                                      SerializedObjectBuffer* message_buffer,
                                      Monitor* spawn_count_monitor,
                                      intptr_t* spawn_count,
                                      const char* package_root,
                                      const char* package_config,
@@ skipping 33 matching lines @@
   if (!cls.IsTopLevel()) {
     const String& class_name = String::Handle(cls.Name());
     class_name_ = NewConstChar(class_name.ToCString());
   }
   message_buffer->StealBuffer(&serialized_message_, &serialized_message_len_);
 
   // Inherit flags from spawning isolate.
   Isolate::Current()->FlagsCopyTo(isolate_flags());
 }
 
-
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      void* init_data,
                                      const char* script_url,
                                      const char* package_root,
                                      const char* package_config,
                                      SerializedObjectBuffer* args_buffer,
                                      SerializedObjectBuffer* message_buffer,
                                      Monitor* spawn_count_monitor,
                                      intptr_t* spawn_count,
                                      bool paused,
@@ skipping 23 matching lines @@
       errors_are_fatal_(errors_are_fatal) {
   function_name_ = NewConstChar("main");
   args_buffer->StealBuffer(&serialized_args_, &serialized_args_len_);
   message_buffer->StealBuffer(&serialized_message_, &serialized_message_len_);
 
   // By default inherit flags from spawning isolate. These can be overridden
   // from the calling code.
   Isolate::Current()->FlagsCopyTo(isolate_flags());
 }
 
-
 IsolateSpawnState::~IsolateSpawnState() {
   delete[] script_url_;
   delete[] package_root_;
   delete[] package_config_;
   delete[] library_url_;
   delete[] class_name_;
   delete[] function_name_;
   free(serialized_args_);
   free(serialized_message_);
 }
 
-
 RawObject* IsolateSpawnState::ResolveFunction() {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
   const String& func_name = String::Handle(zone, String::New(function_name()));
 
   if (library_url() == NULL) {
     // Handle spawnUri lookup rules.
     // Check whether the root library defines a main function.
     const Library& lib =
@@ skipping 57 matching lines @@
     const String& msg = String::Handle(
         zone, String::NewFormatted(
                   "Unable to resolve static method '%s.%s' in library '%s'.",
                   class_name(), function_name(),
                   (library_url() != NULL ? library_url() : script_url())));
     return LanguageError::New(msg);
   }
   return func.raw();
 }
 
-
 RawInstance* IsolateSpawnState::BuildArgs(Thread* thread) {
   return DeserializeObject(thread, serialized_args_, serialized_args_len_);
 }
 
-
 RawInstance* IsolateSpawnState::BuildMessage(Thread* thread) {
   return DeserializeObject(thread, serialized_message_,
                            serialized_message_len_);
 }
 
-
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart