clang-format runtime/vm

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"
@@ skipping 46 matching lines @@
 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);
 
 
-NOT_IN_PRODUCT(
+#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.");
-)
+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_);
-  }
+  void VisitIsolate(Isolate* isolate) { ASSERT(isolate->origin_id() != id_); }
 
  private:
   Dart_Port id_;
   DISALLOW_COPY_AND_ASSIGN(VerifyOriginId);
 };
 #endif
 
 
 static uint8_t* 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 SerializeObject(const Instance& obj,
                             uint8_t** obj_data,
                             intptr_t* obj_len,
                             bool allow_any_object) {
   MessageWriter writer(obj_data, &allocator, 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) {
+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);
   }
 }
 
 
 NoOOBMessageScope::NoOOBMessageScope(Thread* thread) : StackResource(thread) {
   thread->DeferOOBMessageInterrupts();
 }
 
 
 NoOOBMessageScope::~NoOOBMessageScope() {
   thread()->RestoreOOBMessageInterrupts();
 }
 
 
 NoReloadScope::NoReloadScope(Isolate* isolate, Thread* thread)
-    : StackResource(thread),
-      isolate_(isolate) {
+    : StackResource(thread), isolate_(isolate) {
   ASSERT(isolate_ != NULL);
   AtomicOperations::FetchAndIncrement(&(isolate_->no_reload_scope_depth_));
-  ASSERT(
-      AtomicOperations::LoadRelaxed(&(isolate_->no_reload_scope_depth_)) >= 0);
+  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);
+  ASSERT(AtomicOperations::LoadRelaxed(&(isolate_->no_reload_scope_depth_)) >=
+         0);
 }
 
 
 void Isolate::RegisterClass(const Class& cls) {
-  NOT_IN_PRODUCT(
-    if (IsReloading()) {
-      reload_context()->RegisterClass(cls);
-      return;
-    }
-  )
+#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, &allocator, false);
   writer.WriteMessage(msg);
 
-  PortMap::PostMessage(new Message(main_port(),
-                                   data, writer.BytesWritten(),
+  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;
@@ skipping 15 matching lines @@
   // 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) {
-}
+    : isolate_(isolate) {}
 
 
-IsolateMessageHandler::~IsolateMessageHandler() {
-}
+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) {
@@ skipping 34 matching lines @@
       if (!obj2.IsSendPort()) return Error::null();
       const SendPort& send_port = SendPort::Cast(obj2);
       const Object& obj3 = Object::Handle(zone, message.At(3));
       if (!obj3.IsSmi()) return Error::null();
       const intptr_t priority = Smi::Cast(obj3).Value();
       const Object& obj4 = Object::Handle(zone, message.At(4));
       if (!obj4.IsInstance() && !obj4.IsNull()) return Error::null();
       const Instance& response =
           obj4.IsNull() ? Instance::null_instance() : Instance::Cast(obj4);
       if (priority == Isolate::kImmediateAction) {
-        PortMap::PostMessage(SerializeMessage(
-            send_port.Id(), response));
+        PortMap::PostMessage(SerializeMessage(send_port.Id(), response));
       } else {
         ASSERT((priority == Isolate::kBeforeNextEventAction) ||
                (priority == Isolate::kAsEventAction));
         // Update the message so that it will be handled immediately when it
         // is picked up from the message queue the next time.
-        message.SetAt(0, Smi::Handle(zone,
-            Smi::New(Message::kDelayedIsolateLibOOBMsg)));
-        message.SetAt(3, Smi::Handle(zone,
-            Smi::New(Isolate::kImmediateAction)));
-        this->PostMessage(SerializeMessage(
-            Message::kIllegalPort, message),
+        message.SetAt(
+            0, Smi::Handle(zone, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
+        message.SetAt(3,
+                      Smi::Handle(zone, Smi::New(Isolate::kImmediateAction)));
+        this->PostMessage(
+            SerializeMessage(Message::kIllegalPort, message),
             priority == Isolate::kBeforeNextEventAction /* at_head */);
       }
       break;
     }
     case Isolate::kKillMsg:
     case Isolate::kInternalKillMsg:
     case Isolate::kVMRestartMsg: {
       // [ OOB, kKillMsg, terminate capability, priority ]
       if (message.Length() != 4) return Error::null();
       Object& obj = Object::Handle(zone, message.At(3));
       if (!obj.IsSmi()) return Error::null();
       const intptr_t priority = Smi::Cast(obj).Value();
       if (priority == Isolate::kImmediateAction) {
         obj = message.At(2);
         if (I->VerifyTerminateCapability(obj)) {
           // We will kill the current isolate by returning an UnwindError.
           if (msg_type == Isolate::kKillMsg) {
-            const String& msg = String::Handle(String::New(
-                "isolate terminated by Isolate.kill"));
+            const String& msg = String::Handle(
+                String::New("isolate terminated by Isolate.kill"));
             const UnwindError& error =
                 UnwindError::Handle(UnwindError::New(msg));
             error.set_is_user_initiated(true);
             return error.raw();
           } else if (msg_type == Isolate::kInternalKillMsg) {
-            const String& msg = String::Handle(String::New(
-                "isolate terminated by vm"));
+            const String& msg =
+                String::Handle(String::New("isolate terminated by vm"));
             return UnwindError::New(msg);
           } else if (msg_type == Isolate::kVMRestartMsg) {
             // If this is the main isolate, this request to restart
             // will be caught and handled in the embedder.  Otherwise
             // this unwind error will cause the isolate to exit.
-            const String& msg = String::Handle(String::New(
-                "isolate terminated for vm restart"));
+            const String& msg = String::Handle(
+                String::New("isolate terminated for vm restart"));
             const UnwindError& error =
                 UnwindError::Handle(UnwindError::New(msg));
             error.set_is_vm_restart(true);
             return error.raw();
           } else {
             UNREACHABLE();
           }
         } else {
           return Error::null();
         }
       } else {
         ASSERT((priority == Isolate::kBeforeNextEventAction) ||
                (priority == Isolate::kAsEventAction));
         // Update the message so that it will be handled immediately when it
         // is picked up from the message queue the next time.
-        message.SetAt(0, Smi::Handle(zone,
-            Smi::New(Message::kDelayedIsolateLibOOBMsg)));
-        message.SetAt(3, Smi::Handle(zone,
-            Smi::New(Isolate::kImmediateAction)));
-        this->PostMessage(SerializeMessage(
-            Message::kIllegalPort, message),
+        message.SetAt(
+            0, Smi::Handle(zone, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
+        message.SetAt(3,
+                      Smi::Handle(zone, Smi::New(Isolate::kImmediateAction)));
+        this->PostMessage(
+            SerializeMessage(Message::kIllegalPort, message),
             priority == Isolate::kBeforeNextEventAction /* at_head */);
       }
       break;
     }
     case Isolate::kInterruptMsg: {
       // [ OOB, kInterruptMsg, pause capability ]
       if (message.Length() != 3) return Error::null();
       Object& obj = Object::Handle(zone, message.At(2));
       if (!I->VerifyPauseCapability(obj)) return Error::null();
 
@@ skipping 14 matching lines @@
       if (!obj.IsSendPort()) return Error::null();
       const SendPort& listener = SendPort::Cast(obj);
       switch (msg_type) {
         case Isolate::kAddExitMsg: {
           if (message.Length() != 4) return Error::null();
           // [ OOB, msg, listener port, response object ]
           const Object& response = Object::Handle(zone, message.At(3));
           if (!response.IsInstance() && !response.IsNull()) {
             return Error::null();
           }
-          I->AddExitListener(listener,
-                             response.IsNull() ? Instance::null_instance()
-                                               : Instance::Cast(response));
+          I->AddExitListener(listener, response.IsNull()
+                                           ? Instance::null_instance()
+                                           : Instance::Cast(response));
           break;
         }
         case Isolate::kDelExitMsg:
           if (message.Length() != 3) return Error::null();
           I->RemoveExitListener(listener);
           break;
         case Isolate::kAddErrorMsg:
           if (message.Length() != 3) return Error::null();
           I->AddErrorListener(listener);
           break;
@@ skipping 43 matching lines @@
 
 
 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(),
+  TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
                             "HandleMessage");
   tds.SetNumArguments(1);
   tds.CopyArgument(0, "isolateName", I->name());
 #endif
 
   // If the message is in band we lookup the handler to dispatch to.  If the
   // receive port was closed, we drop the message without deserializing it.
   // Illegal port is a special case for artificially enqueued isolate library
   // messages which are handled in C++ code below.
   Object& msg_handler = Object::Handle(zone);
@@ skipping 89 matching lines @@
         if (oob_tag.IsSmi() &&
             (Smi::Cast(oob_tag).Value() == Message::kDelayedIsolateLibOOBMsg)) {
           const Error& error = Error::Handle(HandleLibMessage(msg_arr));
           if (!error.IsNull()) {
             status = ProcessUnhandledException(error);
           }
         }
       }
     }
   } else {
-    const Object& result = Object::Handle(zone,
-        DartLibraryCalls::HandleMessage(msg_handler, msg));
+    const Object& result =
+        Object::Handle(zone, DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
       status = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
 #ifndef PRODUCT
   if (status == kOK) {
     const Object& result =
@@ skipping 31 matching lines @@
   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());
+    OS::Print("vm-service: Dropping event of type PauseExit (%s)\n", I->name());
   }
 }
 #endif  // !PRODUCT
 
 
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
@@ skipping 91 matching lines @@
 
 void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
   api_flags->enable_type_checks = type_checks();
   api_flags->enable_asserts = asserts();
   api_flags->enable_error_on_bad_type = error_on_bad_type();
   api_flags->enable_error_on_bad_override = error_on_bad_override();
 }
 
 
-NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
 void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
   type_checks_ = api_flags.enable_type_checks;
   asserts_ = api_flags.enable_asserts;
   error_on_bad_type_ = api_flags.enable_error_on_bad_type;
   error_on_bad_override_ = api_flags.enable_error_on_bad_override;
   // Leave others at defaults.
-})
+}
+#endif  // !defined(PRODUCT)
 
 
-DEBUG_ONLY(
+#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());
 }
-)
+#endif  // defined(DEBUG)
 
 #if defined(DEBUG)
 #define REUSABLE_HANDLE_SCOPE_INIT(object)                                     \
   reusable_##object##_handle_scope_active_(false),
 #else
 #define REUSABLE_HANDLE_SCOPE_INIT(object)
 #endif  // defined(DEBUG)
 
-#define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
-  object##_handle_(NULL),
+#define REUSABLE_HANDLE_INITIALIZERS(object) object##_handle_(NULL),
 
 // TODO(srdjan): Some Isolate monitors can be shared. Replace their usage with
 // that shared monitor.
 Isolate::Isolate(const Dart_IsolateFlags& api_flags)
-  :   store_buffer_(new StoreBuffer()),
+    : store_buffer_(new StoreBuffer()),
       heap_(NULL),
       user_tag_(0),
       current_tag_(UserTag::null()),
       default_tag_(UserTag::null()),
       object_store_(NULL),
       class_table_(),
       single_step_(false),
       thread_registry_(new ThreadRegistry()),
       safepoint_handler_(new SafepointHandler(this)),
       message_notify_callback_(NULL),
@@ skipping 44 matching lines @@
       all_classes_finalized_(false),
       next_(NULL),
       pause_loop_monitor_(NULL),
       loading_invalidation_gen_(kInvalidGen),
       top_level_parsing_count_(0),
       field_list_mutex_(new Mutex()),
       boxed_field_list_(GrowableObjectArray::null()),
       spawn_count_monitor_(new Monitor()),
       spawn_count_(0),
 #define ISOLATE_METRIC_CONSTRUCTORS(type, variable, name, unit)                \
-      metric_##variable##_(),
+  metric_##variable##_(),
       ISOLATE_METRIC_LIST(ISOLATE_METRIC_CONSTRUCTORS)
 #undef ISOLATE_METRIC_CONSTRUCTORS
-      has_attempted_reload_(false),
+          has_attempted_reload_(false),
       no_reload_scope_depth_(0),
       reload_every_n_stack_overflow_checks_(FLAG_reload_every),
       reload_context_(NULL),
       last_reload_timestamp_(OS::GetCurrentTimeMillis()),
       should_pause_post_service_request_(false) {
   NOT_IN_PRODUCT(FlagsCopyFrom(api_flags));
   // TODO(asiva): A Thread is not available here, need to figure out
   // how the vm_tag (kEmbedderTagId) can be set, these tags need to
   // move to the OSThread structure.
   set_user_tag(UserTags::kDefaultUserTag);
@@ skipping 57 matching lines @@
   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.
+// 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);
 #undef ISOLATE_METRIC_INIT
 
   Heap::Init(result,
              is_vm_isolate
                  ? 0  // New gen size 0; VM isolate should only allocate in old.
                  : FLAG_new_gen_semi_max_size * MBInWords,
              FLAG_old_gen_heap_size * MBInWords,
@@ skipping 28 matching lines @@
   result->set_pause_capability(result->random()->NextUInt64());
   result->set_terminate_capability(result->random()->NextUInt64());
 
   result->BuildName(name_prefix);
   if (FLAG_support_debugger) {
     result->debugger_ = new Debugger();
     result->debugger_->Initialize(result);
   }
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
-      OS::Print("[+] Starting isolate:\n"
-                "\tisolate:    %s\n", result->name());
+      OS::Print(
+          "[+] Starting isolate:\n"
+          "\tisolate:    %s\n",
+          result->name());
     }
   }
 
 #ifndef PRODUCT
   if (FLAG_support_service) {
     ObjectIdRing::Init(result);
   }
 #endif  // !PRODUCT
 
   // Add to isolate list. Shutdown and delete the isolate on failure.
@@ skipping 15 matching lines @@
 
 
 void Isolate::SetupInstructionsSnapshotPage(
     const uint8_t* instructions_snapshot_buffer) {
   InstructionsSnapshot snapshot(instructions_snapshot_buffer);
 #if defined(DEBUG)
   if (FLAG_trace_isolates) {
     OS::Print("Precompiled instructions are at [0x%" Px ", 0x%" Px ")\n",
               reinterpret_cast<uword>(snapshot.instructions_start()),
               reinterpret_cast<uword>(snapshot.instructions_start()) +
-              snapshot.instructions_size());
+                  snapshot.instructions_size());
   }
 #endif
   heap_->SetupExternalPage(snapshot.instructions_start(),
                            snapshot.instructions_size(),
                            /* is_executable = */ true);
 }
 
 
 void Isolate::SetupDataSnapshotPage(const uint8_t* data_snapshot_buffer) {
   DataSnapshot snapshot(data_snapshot_buffer);
 #if defined(DEBUG)
   if (FLAG_trace_isolates) {
-    OS::Print("Precompiled rodata are at [0x%" Px ", 0x%" Px ")\n",
-              reinterpret_cast<uword>(snapshot.data_start()),
-              reinterpret_cast<uword>(snapshot.data_start()) +
-              snapshot.data_size());
+    OS::Print(
+        "Precompiled rodata are at [0x%" Px ", 0x%" Px ")\n",
+        reinterpret_cast<uword>(snapshot.data_start()),
+        reinterpret_cast<uword>(snapshot.data_start()) + snapshot.data_size());
   }
 #endif
-  heap_->SetupExternalPage(snapshot.data_start(),
-                           snapshot.data_size(),
+  heap_->SetupExternalPage(snapshot.data_start(), snapshot.data_size(),
                            /* is_executable = */ false);
 }
 
 
 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) {
@@ skipping 36 matching lines @@
   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());
+  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();
     }
     lib.InitExportedNamesCache();
   }
   TokenStream::CloseSharedTokenList(this);
 }
 
 
 bool Isolate::CanReload() const {
 #ifndef PRODUCT
-  return !ServiceIsolate::IsServiceIsolateDescendant(this) &&
-         is_runnable() && !IsReloading() &&
+  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,
@@ skipping 26 matching lines @@
   Thread* thread = Thread::Current();
   SafepointOperationScope safepoint_scope(thread);
 
   delete reload_context_;
   reload_context_ = NULL;
 }
 #endif  // !PRODUCT
 
 
 void Isolate::DoneFinalizing() {
-  NOT_IN_PRODUCT(
-    if (IsReloading()) {
-      reload_context_->FinalizeLoading();
-    }
-  )
+#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 24 matching lines @@
   if (FLAG_support_service && Service::isolate_stream.enabled()) {
     ServiceEvent runnableEvent(this, ServiceEvent::kIsolateRunnable);
     Service::HandleEvent(&runnableEvent);
   }
 #endif  // !PRODUCT
   return true;
 }
 
 
 bool Isolate::VerifyPauseCapability(const Object& capability) const {
-  return !capability.IsNull() &&
-      capability.IsCapability() &&
-      (pause_capability() == Capability::Cast(capability).Id());
+  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());
+  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());
@@ skipping 18 matching lines @@
     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());
+      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());
+      current_zone(), object_store()->exit_listeners());
   SendPort& current = SendPort::Handle(current_zone());
   intptr_t insertion_index = -1;
   for (intptr_t i = 0; i < listeners.Length(); i += 2) {
     current ^= listeners.At(i);
     if (current.IsNull()) {
       if (insertion_index < 0) {
         insertion_index = i;
       }
     } else if (current.Id() == listener.Id()) {
       listeners.SetAt(i + 1, response);
@@ skipping 146 matching lines @@
     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.
+// 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();
     result = state->ResolveFunction();
     bool is_spawn_uri = state->is_spawn_uri();
@@ skipping 34 matching lines @@
     // Since this function ("RunIsolate") is used for both Isolate.spawn and
     // Isolate.spawnUri we also send a boolean flag as argument so that the
     // "_startIsolate" function can act corresponding to how the isolate was
     // created.
     const Array& args = Array::Handle(Array::New(7));
     args.SetAt(0, SendPort::Handle(SendPort::New(state->parent_port())));
     args.SetAt(1, Instance::Handle(func.ImplicitStaticClosure()));
     args.SetAt(2, Instance::Handle(state->BuildArgs(thread)));
     args.SetAt(3, Instance::Handle(state->BuildMessage(thread)));
     args.SetAt(4, is_spawn_uri ? Bool::True() : Bool::False());
-    args.SetAt(5, ReceivePort::Handle(
-        ReceivePort::New(isolate->main_port(), true /* control port */)));
+    args.SetAt(5, ReceivePort::Handle(ReceivePort::New(
+                      isolate->main_port(), true /* control port */)));
     args.SetAt(6, capabilities);
 
     const Library& lib = Library::Handle(Library::IsolateLibrary());
     const String& entry_name = String::Handle(String::New("_startIsolate"));
     const Function& entry_point =
         Function::Handle(lib.LookupLocalFunction(entry_name));
     ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
 
     result = DartEntry::InvokeFunction(entry_point, args);
     if (result.IsError()) {
@@ skipping 10 matching lines @@
   // 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();
     ASSERT(thread->isolate() == isolate);
     StackZone zone(thread);
     HandleScope handle_scope(thread);
-    // TODO(27003): Enable for precompiled.
+// TODO(27003): Enable for precompiled.
 #if defined(DEBUG) && !defined(DART_PRECOMPILED_RUNTIME)
     if (!isolate->HasAttemptedReload()) {
       // For this verification we need to stop the background compiler earlier.
       // This would otherwise happen in Dart::ShowdownIsolate.
       isolate->StopBackgroundCompiler();
       isolate->heap()->CollectAllGarbage();
       VerifyCanonicalVisitor check_canonical(thread);
       isolate->heap()->IterateObjects(&check_canonical);
     }
 #endif  // DEBUG
     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_));
+  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,
+  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());
@@ skipping 43 matching lines @@
       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()) {
-  }
+  FinalizeWeakPersistentHandlesVisitor() : HandleVisitor(Thread::Current()) {}
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     FinalizationQueue* queue = NULL;  // Finalize in the foreground.
     handle->UpdateUnreachable(thread()->isolate(), queue);
   }
 
  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() ||
+    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 messsages 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();
   }
 
-  // Dump all timing data for the isolate.
+// Dump all timing data for the isolate.
 #ifndef PRODUCT
   if (FLAG_support_timeline && FLAG_timing) {
     TimelinePauseTrace tpt;
     tpt.Print();
   }
 #endif  // !PRODUCT
 
   // Finalize any weak persistent handles with a non-null referent.
   FinalizeWeakPersistentHandlesVisitor visitor;
   api_state()->weak_persistent_handles().VisitHandles(&visitor);
 
   if (FLAG_dump_megamorphic_stats) {
     MegamorphicCacheTable::PrintSizes(this);
   }
   if (FLAG_trace_isolates) {
     heap()->PrintSizes();
     Symbols::DumpStats();
-    OS::Print("[-] Stopping isolate:\n"
-              "\tisolate:    %s\n", name());
+    OS::Print(
+        "[-] Stopping isolate:\n"
+        "\tisolate:    %s\n",
+        name());
   }
   if (FLAG_print_metrics) {
     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");
@@ skipping 40 matching lines @@
   // Don't allow anymore dart code to execution on this isolate.
   thread->ClearStackLimit();
 
   // First, perform higher-level cleanup that may need to allocate.
   {
     // Ensure we have a zone and handle scope so that we can call VM functions.
     StackZone stack_zone(thread);
     HandleScope handle_scope(thread);
 
     // Write compiler stats data if enabled.
-    if (FLAG_support_compiler_stats && FLAG_compiler_stats
-        && !ServiceIsolate::IsServiceIsolateDescendant(this)
-        && (this != Dart::vm_isolate())) {
+    if (FLAG_support_compiler_stats && FLAG_compiler_stats &&
+        !ServiceIsolate::IsServiceIsolateDescendant(this) &&
+        (this != Dart::vm_isolate())) {
       OS::Print("%s", aggregate_compiler_stats()->PrintToZone());
     }
   }
 
   // Remove this isolate from the list *before* we start tearing it down, to
   // avoid exposing it in a state of decay.
   RemoveIsolateFromList(this);
 
   if (heap_ != NULL) {
     // Wait for any concurrent GC tasks to finish before shutting down.
     // TODO(koda): Support faster sweeper shutdown (e.g., after current page).
     PageSpace* old_space = heap_->old_space();
     MonitorLocker ml(old_space->tasks_lock());
     while (old_space->tasks() > 0) {
       ml.Wait();
     }
   }
 
-  if (FLAG_check_reloaded && is_runnable() &&
-      (this != Dart::vm_isolate()) &&
+  if (FLAG_check_reloaded && is_runnable() && (this != Dart::vm_isolate()) &&
       !ServiceIsolate::IsServiceIsolateDescendant(this)) {
     if (!HasAttemptedReload()) {
-      FATAL("Isolate did not reload before exiting and "
-            "--check-reloaded is enabled.\n");
+      FATAL(
+          "Isolate did not reload before exiting and "
+          "--check-reloaded is enabled.\n");
     }
   }
 
   // Then, proceed with low-level teardown.
   LowLevelShutdown();
 
 #if defined(DEBUG)
   // No concurrent sweeper tasks should be running at this point.
   if (heap_ != NULL) {
     PageSpace* old_space = heap_->old_space();
@@ skipping 50 matching lines @@
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&tag_table_));
 
   if (background_compiler() != NULL) {
     background_compiler()->VisitPointers(visitor);
   }
 
   // Visit the deoptimized code array which is stored in the isolate.
   visitor->VisitPointer(
       reinterpret_cast<RawObject**>(&deoptimized_code_array_));
 
-  visitor->VisitPointer(
-        reinterpret_cast<RawObject**>(&sticky_error_));
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(&sticky_error_));
 
   // Visit the pending service extension calls.
   visitor->VisitPointer(
       reinterpret_cast<RawObject**>(&pending_service_extension_calls_));
 
   // Visit the registered service extension handlers.
   visitor->VisitPointer(
       reinterpret_cast<RawObject**>(&registered_service_extension_handlers_));
 
   // Visit the boxed_field_list_.
   // 'boxed_field_list_' access via mutator and background compilation threads
   // is guarded with a monitor. This means that we can visit it only
   // when at safepoint or the field_list_mutex_ lock has been taken.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&boxed_field_list_));
 
   // Visit objects in the debugger.
   if (FLAG_support_debugger) {
     debugger()->VisitObjectPointers(visitor);
   }
 
-  NOT_IN_PRODUCT(
-    // Visit objects that are being used for isolate reload.
-    if (reload_context() != NULL) {
-      reload_context()->VisitObjectPointers(visitor);
-    }
-    if (ServiceIsolate::IsServiceIsolate(this)) {
-      ServiceIsolate::VisitObjectPointers(visitor);
-    }
-  )
+#if !defined(PRODUCT)
+  // Visit objects that are being used for isolate reload.
+  if (reload_context() != NULL) {
+    reload_context()->VisitObjectPointers(visitor);
+  }
+  if (ServiceIsolate::IsServiceIsolate(this)) {
+    ServiceIsolate::VisitObjectPointers(visitor);
+  }
+#endif  // !defined(PRODUCT)
 
   // Visit objects that are being used for deoptimization.
   if (deopt_context() != NULL) {
     deopt_context()->VisitObjectPointers(visitor);
   }
 
   // Visit objects in all threads (e.g., Dart stack, handles in zones).
   thread_registry()->VisitObjectPointers(visitor, validate_frames);
 }
 
@@ skipping 27 matching lines @@
   ASSERT(raw_class->ptr()->id_ == cid);
 #endif
   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);
+  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;
 }
@@ skipping 38 matching lines @@
 void Isolate::PrintJSON(JSONStream* stream, bool ref) {
   if (!FLAG_support_service) {
     return;
   }
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", (ref ? "@Isolate" : "Isolate"));
   jsobj.AddFixedServiceId("isolates/%" Pd64 "",
                           static_cast<int64_t>(main_port()));
 
   jsobj.AddProperty("name", debugger_name());
-  jsobj.AddPropertyF("number", "%" Pd64 "",
-                     static_cast<int64_t>(main_port()));
+  jsobj.AddPropertyF("number", "%" Pd64 "", static_cast<int64_t>(main_port()));
   if (ref) {
     return;
   }
   jsobj.AddPropertyF("_originNumber", "%" Pd64 "",
                      static_cast<int64_t>(origin_id()));
   int64_t start_time_millis = start_time() / kMicrosecondsPerMillisecond;
   jsobj.AddPropertyTimeMillis("startTime", start_time_millis);
   {
     JSONObject jsheap(&jsobj, "_heaps");
     heap()->PrintToJSONObject(Heap::kNew, &jsheap);
@@ skipping 12 matching lines @@
     jsobj.AddProperty("pauseEvent", &pause_event);
   } else if (message_handler()->is_paused_on_start() ||
              message_handler()->should_pause_on_start()) {
     ASSERT((debugger() == NULL) || (debugger()->PauseEvent() == NULL));
     ServiceEvent pause_event(this, ServiceEvent::kPauseStart);
     jsobj.AddProperty("pauseEvent", &pause_event);
   } else if (message_handler()->is_paused_on_exit() &&
              ((debugger() == NULL) || (debugger()->PauseEvent() == NULL))) {
     ServiceEvent pause_event(this, ServiceEvent::kPauseExit);
     jsobj.AddProperty("pauseEvent", &pause_event);
-  } else if ((debugger() != NULL) &&
-             (debugger()->PauseEvent() != NULL) &&
+  } else if ((debugger() != NULL) && (debugger()->PauseEvent() != NULL) &&
              !resume_request_) {
     jsobj.AddProperty("pauseEvent", debugger()->PauseEvent());
   } else {
     ServiceEvent pause_event(this, ServiceEvent::kResume);
 
     if (debugger() != NULL) {
       // TODO(turnidge): Don't compute a full stack trace.
       DebuggerStackTrace* stack = debugger()->StackTrace();
       if (stack->Length() > 0) {
         pause_event.set_top_frame(stack->FrameAt(0));
       }
     }
     jsobj.AddProperty("pauseEvent", &pause_event);
   }
 
-  const Library& lib =
-      Library::Handle(object_store()->root_library());
+  const Library& lib = Library::Handle(object_store()->root_library());
   if (!lib.IsNull()) {
     jsobj.AddProperty("rootLib", lib);
   }
 
   if (FLAG_profiler) {
     JSONObject tagCounters(&jsobj, "_tagCounters");
     vm_tag_counters()->PrintToJSONObject(&tagCounters);
   }
   if (Thread::Current()->sticky_error() != Object::null()) {
     Error& error = Error::Handle(Thread::Current()->sticky_error());
@@ skipping 20 matching lines @@
   }
 
   {
     JSONArray breakpoints(&jsobj, "breakpoints");
     if (debugger() != NULL) {
       debugger()->PrintBreakpointsToJSONArray(&breakpoints);
     }
   }
 
   Dart_ExceptionPauseInfo pause_info = (debugger() != NULL)
-      ? debugger()->GetExceptionPauseInfo()
-      : kNoPauseOnExceptions;
+                                           ? debugger()->GetExceptionPauseInfo()
+                                           : kNoPauseOnExceptions;
   jsobj.AddProperty("exceptionPauseMode",
                     ExceptionPauseInfoToServiceEnum(pause_info));
 
   if (debugger() != NULL) {
     JSONObject settings(&jsobj, "_debuggerSettings");
     debugger()->PrintSettingsToJSONObject(&settings);
   }
 
   {
     GrowableObjectArray& handlers =
@@ skipping 52 matching lines @@
   deoptimized_code.Add(code);
 }
 
 
 void Isolate::clear_sticky_error() {
   sticky_error_ = Error::null();
 }
 
 
 void Isolate::set_pending_service_extension_calls(
-      const GrowableObjectArray& value) {
+    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();
 }
 
 
@@ skipping 68 matching lines @@
     ASSERT(!parameter_values.IsNull());
     arguments.SetAt(kPendingValuesIndex, parameter_values);
     reply_port ^= calls.At(i + kPendingReplyPortIndex);
     ASSERT(!reply_port.IsNull());
     arguments.SetAt(kPendingReplyPortIndex, reply_port);
     id ^= calls.At(i + kPendingIdIndex);
     arguments.SetAt(kPendingIdIndex, id);
     arguments.SetAt(kPendingEntrySize, Bool::Get(FLAG_trace_service));
 
     if (FLAG_trace_service) {
-      OS::Print(
-          "[+%" Pd64 "ms] Isolate %s invoking _runExtension for %s\n",
-          Dart::timestamp(), name(), method_name.ToCString());
+      OS::Print("[+%" Pd64 "ms] Isolate %s invoking _runExtension for %s\n",
+                Dart::timestamp(), name(), method_name.ToCString());
     }
     result = DartEntry::InvokeFunction(run_extension, arguments);
     if (FLAG_trace_service) {
-      OS::Print(
-          "[+%" Pd64 "ms] Isolate %s : _runExtension complete for %s\n",
-          Dart::timestamp(), name(), method_name.ToCString());
+      OS::Print("[+%" Pd64 "ms] Isolate %s : _runExtension complete for %s\n",
+                Dart::timestamp(), name(), method_name.ToCString());
     }
     // Propagate the error.
     if (result.IsError()) {
       // Remaining service extension calls are dropped.
       if (!result.IsUnwindError()) {
         // Send error back over the protocol.
-        Service::PostError(method_name,
-                           parameter_keys,
-                           parameter_values,
-                           reply_port,
-                           id,
-                           Error::Cast(result));
+        Service::PostError(method_name, parameter_keys, parameter_values,
+                           reply_port, id, Error::Cast(result));
       }
       return result.raw();
     }
     // Drain the microtask queue.
     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::timestamp(), name(), method_name.ToCString());
+    OS::Print("[+%" Pd64 "ms] Isolate %s ENQUEUING request for extension %s\n",
+              Dart::timestamp(), name(), method_name.ToCString());
   }
   GrowableObjectArray& calls =
       GrowableObjectArray::Handle(pending_service_extension_calls());
   if (calls.IsNull()) {
     calls ^= GrowableObjectArray::New();
     ASSERT(!calls.IsNull());
     set_pending_service_extension_calls(calls);
   }
   ASSERT(kPendingHandlerIndex == 0);
   calls.Add(closure);
@@ skipping 84 matching lines @@
   // 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();
   MonitorLocker ml(pause_loop_monitor_);
 
-  Dart_MessageNotifyCallback saved_notify_callback =
-      message_notify_callback();
+  Dart_MessageNotifyCallback saved_notify_callback = message_notify_callback();
   set_message_notify_callback(Isolate::WakePauseEventHandler);
 
   const bool had_isolate_reload_context = reload_context() != NULL;
   const int64_t start_time_micros =
       !had_isolate_reload_context ? 0 : reload_context()->start_time_micros();
   bool resume = false;
   while (true) {
     // Handle all available vm service messages, up to a resume
     // request.
     while (!resume && Dart_HasServiceMessages()) {
       ml.Exit();
       resume = Dart_HandleServiceMessages();
       ml.Enter();
     }
     if (resume) {
       break;
     }
 
     if (had_isolate_reload_context && (reload_context() == NULL)) {
       if (FLAG_trace_reload) {
         const int64_t reload_time_micros =
             OS::GetCurrentMonotonicMicros() - start_time_micros;
-        double reload_millis =
-            MicrosecondsToMilliseconds(reload_time_micros);
+        double reload_millis = MicrosecondsToMilliseconds(reload_time_micros);
         OS::Print("Reloading has finished! (%.2f ms)\n", reload_millis);
       }
       break;
     }
 
     // Wait for more service messages.
     Monitor::WaitResult res = ml.Wait();
     ASSERT(res == Monitor::kNotified);
   }
   set_message_notify_callback(saved_notify_callback);
@@ skipping 115 matching lines @@
   imm.value.as_int32 = Isolate::kImmediateAction;
   list_values[3] = &imm;
 
   {
     uint8_t* buffer = NULL;
     ApiMessageWriter writer(&buffer, allocator);
     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));
+    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) {}
 
@@ skipping 217 matching lines @@
 
   String& func_name = String::Handle();
   func_name ^= func.name();
   func_name ^= String::ScrubName(func_name);
   function_name_ = NewConstChar(func_name.ToCString());
   if (!cls.IsTopLevel()) {
     const String& class_name = String::Handle(cls.Name());
     class_name_ = NewConstChar(class_name.ToCString());
   }
   bool can_send_any_object = true;
-  SerializeObject(message,
-                  &serialized_message_,
-                  &serialized_message_len_,
+  SerializeObject(message, &serialized_message_, &serialized_message_len_,
                   can_send_any_object);
   // 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,
@@ skipping 22 matching lines @@
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
       spawn_count_monitor_(spawn_count_monitor),
       spawn_count_(spawn_count),
       isolate_flags_(),
       paused_(paused),
       errors_are_fatal_(errors_are_fatal) {
   function_name_ = NewConstChar("main");
   bool can_send_any_object = false;
-  SerializeObject(args,
-                  &serialized_args_,
-                  &serialized_args_len_,
+  SerializeObject(args, &serialized_args_, &serialized_args_len_,
                   can_send_any_object);
-  SerializeObject(message,
-                  &serialized_message_,
-                  &serialized_message_len_,
+  SerializeObject(message, &serialized_message_, &serialized_message_len_,
                   can_send_any_object);
   // 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 = Library::Handle(zone,
-                                         I->object_store()->root_library());
+    const Library& lib =
+        Library::Handle(zone, I->object_store()->root_library());
     Function& func = Function::Handle(zone, lib.LookupLocalFunction(func_name));
     if (func.IsNull()) {
       // Check whether main is reexported from the root library.
       const Object& obj = Object::Handle(zone, lib.LookupReExport(func_name));
       if (obj.IsFunction()) {
         func ^= obj.raw();
       }
     }
     if (func.IsNull()) {
-      const String& msg = String::Handle(zone, String::NewFormatted(
-          "Unable to resolve function '%s' in script '%s'.",
-          function_name(), script_url()));
+      const String& msg = String::Handle(
+          zone, String::NewFormatted(
+                    "Unable to resolve function '%s' in script '%s'.",
+                    function_name(), script_url()));
       return LanguageError::New(msg);
     }
     return func.raw();
   }
 
   // Lookup the to be spawned function for the Isolate.spawn implementation.
   // Resolve the library.
   const String& lib_url = String::Handle(zone, String::New(library_url()));
-  const Library& lib = Library::Handle(zone,
-                                       Library::LookupLibrary(thread, lib_url));
+  const Library& lib =
+      Library::Handle(zone, Library::LookupLibrary(thread, lib_url));
   if (lib.IsNull() || lib.IsError()) {
-    const String& msg = String::Handle(zone, String::NewFormatted(
-        "Unable to find library '%s'.", library_url()));
+    const String& msg = String::Handle(
+        zone,
+        String::NewFormatted("Unable to find library '%s'.", library_url()));
     return LanguageError::New(msg);
   }
 
   // Resolve the function.
   if (class_name() == NULL) {
-    const Function& func = Function::Handle(zone,
-                                            lib.LookupLocalFunction(func_name));
+    const Function& func =
+        Function::Handle(zone, lib.LookupLocalFunction(func_name));
     if (func.IsNull()) {
-      const String& msg = String::Handle(zone, String::NewFormatted(
-          "Unable to resolve function '%s' in library '%s'.",
-          function_name(), library_url()));
+      const String& msg = String::Handle(
+          zone, String::NewFormatted(
+                    "Unable to resolve function '%s' in library '%s'.",
+                    function_name(), library_url()));
       return LanguageError::New(msg);
     }
     return func.raw();
   }
 
   const String& cls_name = String::Handle(zone, String::New(class_name()));
   const Class& cls = Class::Handle(zone, lib.LookupLocalClass(cls_name));
   if (cls.IsNull()) {
-    const String& msg = String::Handle(zone, String::NewFormatted(
-          "Unable to resolve class '%s' in library '%s'.",
-          class_name(),
-          (library_url() != NULL ? library_url() : script_url())));
+    const String& msg = String::Handle(
+        zone, String::NewFormatted(
+                  "Unable to resolve class '%s' in library '%s'.", class_name(),
+                  (library_url() != NULL ? library_url() : script_url())));
     return LanguageError::New(msg);
   }
   const Function& func =
       Function::Handle(zone, cls.LookupStaticFunctionAllowPrivate(func_name));
   if (func.IsNull()) {
-    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())));
+    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_);
+  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