clang-format runtime/vm

runtime/vm/service.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/service.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 30 matching lines @@
 #include "vm/version.h"
 
 namespace dart {
 
 #define Z (T->zone())
 
 
 DECLARE_FLAG(bool, trace_service);
 DECLARE_FLAG(bool, trace_service_pause_events);
 DECLARE_FLAG(bool, profile_vm);
-DEFINE_FLAG(charp, vm_name, "vm",
+DEFINE_FLAG(charp,
+            vm_name,
+            "vm",
             "The default name of this vm as reported by the VM service "
             "protocol");
 
-DEFINE_FLAG(bool, warn_on_pause_with_no_debugger, false,
+DEFINE_FLAG(bool,
+            warn_on_pause_with_no_debugger,
+            false,
             "Print a message when an isolate is paused but there is no "
             "debugger attached.");
 
 #ifndef PRODUCT
 // The name of this of this vm as reported by the VM service protocol.
 static char* vm_name = NULL;
 
 
 static const char* GetVMName() {
   if (vm_name == NULL) {
     return FLAG_vm_name;
   }
   return vm_name;
 }
 
 
-ServiceIdZone::ServiceIdZone() {
-}
+ServiceIdZone::ServiceIdZone() {}
 
 
-ServiceIdZone::~ServiceIdZone() {
-}
+ServiceIdZone::~ServiceIdZone() {}
 
 
 RingServiceIdZone::RingServiceIdZone()
-    : ring_(NULL),
-      policy_(ObjectIdRing::kAllocateId) {
-}
+    : ring_(NULL), policy_(ObjectIdRing::kAllocateId) {}
 
 
-RingServiceIdZone::~RingServiceIdZone() {
-}
+RingServiceIdZone::~RingServiceIdZone() {}
 
 
-void RingServiceIdZone::Init(
-    ObjectIdRing* ring, ObjectIdRing::IdPolicy policy) {
+void RingServiceIdZone::Init(ObjectIdRing* ring,
+                             ObjectIdRing::IdPolicy policy) {
   ring_ = ring;
   policy_ = policy;
 }
 
 
 char* RingServiceIdZone::GetServiceId(const Object& obj) {
   ASSERT(ring_ != NULL);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(zone != NULL);
@@ skipping 19 matching lines @@
 StreamInfo Service::isolate_stream("Isolate");
 StreamInfo Service::debug_stream("Debug");
 StreamInfo Service::gc_stream("GC");
 StreamInfo Service::echo_stream("_Echo");
 StreamInfo Service::graph_stream("_Graph");
 StreamInfo Service::logging_stream("_Logging");
 StreamInfo Service::extension_stream("Extension");
 StreamInfo Service::timeline_stream("Timeline");
 
 static StreamInfo* streams_[] = {
-  &Service::vm_stream,
-  &Service::isolate_stream,
-  &Service::debug_stream,
-  &Service::gc_stream,
-  &Service::echo_stream,
-  &Service::graph_stream,
-  &Service::logging_stream,
-  &Service::extension_stream,
-  &Service::timeline_stream,
+    &Service::vm_stream,       &Service::isolate_stream,
+    &Service::debug_stream,    &Service::gc_stream,
+    &Service::echo_stream,     &Service::graph_stream,
+    &Service::logging_stream,  &Service::extension_stream,
+    &Service::timeline_stream,
 };
 
 
 bool Service::ListenStream(const char* stream_id) {
   if (FLAG_trace_service) {
-    OS::Print("vm-service: starting stream '%s'\n",
-              stream_id);
+    OS::Print("vm-service: starting stream '%s'\n", stream_id);
   }
-  intptr_t num_streams = sizeof(streams_) /
-                         sizeof(streams_[0]);
+  intptr_t num_streams = sizeof(streams_) / sizeof(streams_[0]);
   for (intptr_t i = 0; i < num_streams; i++) {
     if (strcmp(stream_id, streams_[i]->id()) == 0) {
       streams_[i]->set_enabled(true);
       return true;
     }
   }
   if (stream_listen_callback_) {
     Thread* T = Thread::Current();
     TransitionVMToNative transition(T);
     return (*stream_listen_callback_)(stream_id);
   }
   return false;
 }
 
 
 void Service::CancelStream(const char* stream_id) {
   if (FLAG_trace_service) {
-    OS::Print("vm-service: stopping stream '%s'\n",
-              stream_id);
+    OS::Print("vm-service: stopping stream '%s'\n", stream_id);
   }
-  intptr_t num_streams = sizeof(streams_) /
-                         sizeof(streams_[0]);
+  intptr_t num_streams = sizeof(streams_) / sizeof(streams_[0]);
   for (intptr_t i = 0; i < num_streams; i++) {
     if (strcmp(stream_id, streams_[i]->id()) == 0) {
       streams_[i]->set_enabled(false);
       return;
     }
   }
   if (stream_cancel_callback_) {
     Thread* T = Thread::Current();
     TransitionVMToNative transition(T);
     return (*stream_cancel_callback_)(stream_id);
   }
 }
 
 RawObject* Service::RequestAssets() {
   Thread* T = Thread::Current();
   TransitionVMToNative transition(T);
   Api::Scope api_scope(T);
   if (get_service_assets_callback_ == NULL) {
     return Object::null();
   }
   Dart_Handle handle = get_service_assets_callback_();
   if (Dart_IsError(handle)) {
     Dart_PropagateError(handle);
   }
   const Object& object = Object::Handle(Api::UnwrapHandle(handle));
   if (object.IsNull()) {
     return Object::null();
   }
   if (!object.IsTypedData()) {
-    const String& error_message =
-        String::Handle(
-            String::New("An implementation of Dart_GetVMServiceAssetsArchive "
-                        "should return a Uint8Array or null."));
+    const String& error_message = String::Handle(
+        String::New("An implementation of Dart_GetVMServiceAssetsArchive "
+                    "should return a Uint8Array or null."));
     const Error& error = Error::Handle(ApiError::New(error_message));
     Exceptions::PropagateError(error);
     return Object::null();
   }
   const TypedData& typed_data = TypedData::Cast(object);
   if (typed_data.ElementSizeInBytes() != 1) {
-    const String& error_message =
-        String::Handle(
-            String::New("An implementation of Dart_GetVMServiceAssetsArchive "
-                        "should return a Uint8Array or null."));
+    const String& error_message = String::Handle(
+        String::New("An implementation of Dart_GetVMServiceAssetsArchive "
+                    "should return a Uint8Array or null."));
     const Error& error = Error::Handle(ApiError::New(error_message));
     Exceptions::PropagateError(error);
     return Object::null();
   }
   return Api::UnwrapHandle(handle);
 }
 
 
 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);
   if (new_ptr == NULL) {
     OUT_OF_MEMORY();
   }
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
-static void PrintMissingParamError(JSONStream* js,
-                                   const char* param) {
-  js->PrintError(kInvalidParams,
-                 "%s expects the '%s' parameter", js->method(), param);
+static void PrintMissingParamError(JSONStream* js, const char* param) {
+  js->PrintError(kInvalidParams, "%s expects the '%s' parameter", js->method(),
+                 param);
 }
 
 
-static void PrintInvalidParamError(JSONStream* js,
-                                   const char* param) {
-  js->PrintError(kInvalidParams,
-                 "%s: invalid '%s' parameter: %s",
-                 js->method(), param, js->LookupParam(param));
+static void PrintInvalidParamError(JSONStream* js, const char* param) {
+  js->PrintError(kInvalidParams, "%s: invalid '%s' parameter: %s", js->method(),
+                 param, js->LookupParam(param));
 }
 
 
-static void PrintIllegalParamError(JSONStream* js,
-                                   const char* param) {
-  js->PrintError(kInvalidParams,
-                 "%s: illegal '%s' parameter: %s",
-                 js->method(), param, js->LookupParam(param));
+static void PrintIllegalParamError(JSONStream* js, const char* param) {
+  js->PrintError(kInvalidParams, "%s: illegal '%s' parameter: %s", js->method(),
+                 param, js->LookupParam(param));
 }
 
 
 static void PrintUnrecognizedMethodError(JSONStream* js) {
   js->PrintError(kMethodNotFound, NULL);
 }
 
 
 static void PrintSuccess(JSONStream* js) {
   JSONObject jsobj(js);
@@ skipping 147 matching lines @@
   ClassTable* class_table = isolate->class_table();
   ASSERT(class_table != NULL);
   return class_table->At(cid);
 }
 
 
 // TODO(johnmccutchan): Split into separate file and write unit tests.
 class MethodParameter {
  public:
   MethodParameter(const char* name, bool required)
-      : name_(name), required_(required) {
-  }
+      : name_(name), required_(required) {}
 
-  virtual ~MethodParameter() { }
+  virtual ~MethodParameter() {}
 
-  virtual bool Validate(const char* value) const {
-    return true;
-  }
+  virtual bool Validate(const char* value) const { return true; }
 
-  virtual bool ValidateObject(const Object& value) const {
-    return true;
-  }
+  virtual bool ValidateObject(const Object& value) const { return true; }
 
-  const char* name() const {
-    return name_;
-  }
+  const char* name() const { return name_; }
 
-  bool required() const {
-    return required_;
-  }
+  bool required() const { return required_; }
 
   virtual void PrintError(const char* name,
                           const char* value,
                           JSONStream* js) const {
     PrintInvalidParamError(js, name);
   }
 
   virtual void PrintErrorObject(const char* name,
                                 const Object& value,
                                 JSONStream* js) const {
     PrintInvalidParamError(js, name);
   }
 
  private:
   const char* name_;
   bool required_;
 };
 
 
 class DartStringParameter : public MethodParameter {
  public:
   DartStringParameter(const char* name, bool required)
-      : MethodParameter(name, required) {
-  }
+      : MethodParameter(name, required) {}
 
   virtual bool ValidateObject(const Object& value) const {
     return value.IsString();
   }
 };
 
 
 class DartListParameter : public MethodParameter {
  public:
   DartListParameter(const char* name, bool required)
-      : MethodParameter(name, required) {
-  }
+      : MethodParameter(name, required) {}
 
   virtual bool ValidateObject(const Object& value) const {
     return value.IsArray() || value.IsGrowableObjectArray();
   }
 };
 
 
 class NoSuchParameter : public MethodParameter {
  public:
-  explicit NoSuchParameter(const char* name)
-    : MethodParameter(name, false) {
-  }
+  explicit NoSuchParameter(const char* name) : MethodParameter(name, false) {}
 
-  virtual bool Validate(const char* value) const {
-    return (value == NULL);
-  }
+  virtual bool Validate(const char* value) const { return (value == NULL); }
 
   virtual bool ValidateObject(const Object& value) const {
     return value.IsNull();
   }
 };
 
 
 class BoolParameter : public MethodParameter {
  public:
   BoolParameter(const char* name, bool required)
-      : MethodParameter(name, required) {
-  }
+      : MethodParameter(name, required) {}
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
       return false;
     }
     return (strcmp("true", value) == 0) || (strcmp("false", value) == 0);
   }
 
   static bool Parse(const char* value, bool default_value = false) {
     if (value == NULL) {
       return default_value;
     }
     return strcmp("true", value) == 0;
   }
 };
 
 
 class UIntParameter : public MethodParameter {
  public:
   UIntParameter(const char* name, bool required)
-      : MethodParameter(name, required) {
-  }
+      : MethodParameter(name, required) {}
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
       return false;
     }
     for (const char* cp = value; *cp != '\0'; cp++) {
       if (*cp < '0' || *cp > '9') {
         return false;
       }
     }
     return true;
   }
 
   static intptr_t Parse(const char* value) {
     if (value == NULL) {
       return -1;
     }
     char* end_ptr = NULL;
     uintptr_t result = strtoul(value, &end_ptr, 10);
     ASSERT(*end_ptr == '\0');  // Parsed full string
     return result;
   }
 };
 
 
 class Int64Parameter : public MethodParameter {
  public:
   Int64Parameter(const char* name, bool required)
-      : MethodParameter(name, required) {
-  }
+      : MethodParameter(name, required) {}
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
       return false;
     }
     for (const char* cp = value; *cp != '\0'; cp++) {
       if ((*cp < '0' || *cp > '9') && (*cp != '-')) {
         return false;
       }
     }
     return true;
   }
 
   static int64_t Parse(const char* value, int64_t default_value = -1) {
     if ((value == NULL) || (*value == '\0')) {
       return default_value;
     }
     char* end_ptr = NULL;
     int64_t result = strtoll(value, &end_ptr, 10);
     ASSERT(*end_ptr == '\0');  // Parsed full string
     return result;
   }
 };
 
 
 class IdParameter : public MethodParameter {
  public:
   IdParameter(const char* name, bool required)
-      : MethodParameter(name, required) {
-  }
+      : MethodParameter(name, required) {}
 
-  virtual bool Validate(const char* value) const {
-    return (value != NULL);
-  }
+  virtual bool Validate(const char* value) const { return (value != NULL); }
 };
 
 
 class RunnableIsolateParameter : public MethodParameter {
  public:
   explicit RunnableIsolateParameter(const char* name)
-      : MethodParameter(name, true) {
-  }
+      : MethodParameter(name, true) {}
 
   virtual bool Validate(const char* value) const {
     Isolate* isolate = Isolate::Current();
     return (value != NULL) && (isolate != NULL) && (isolate->is_runnable());
   }
 
   virtual void PrintError(const char* name,
                           const char* value,
                           JSONStream* js) const {
     js->PrintError(kIsolateMustBeRunnable,
                    "Isolate must be runnable before this request is made.");
   }
 };
 
 
 #define ISOLATE_PARAMETER new IdParameter("isolateId", true)
 #define NO_ISOLATE_PARAMETER new NoSuchParameter("isolateId")
 #define RUNNABLE_ISOLATE_PARAMETER new RunnableIsolateParameter("isolateId")
 
 class EnumParameter : public MethodParameter {
  public:
   EnumParameter(const char* name, bool required, const char* const* enums)
-      : MethodParameter(name, required),
-        enums_(enums) {
-  }
+      : MethodParameter(name, required), enums_(enums) {}
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
       return true;
     }
     for (intptr_t i = 0; enums_[i] != NULL; i++) {
       if (strcmp(value, enums_[i]) == 0) {
         return true;
       }
     }
     return false;
   }
 
  private:
   const char* const* enums_;
 };
 
 
 // If the key is not found, this function returns the last element in the
 // values array. This can be used to encode the default value.
-template<typename T>
+template <typename T>
 T EnumMapper(const char* value, const char* const* enums, T* values) {
   ASSERT(value != NULL);
   intptr_t i = 0;
   for (i = 0; enums[i] != NULL; i++) {
     if (strcmp(value, enums[i]) == 0) {
       return values[i];
     }
   }
   // Default value.
   return values[i];
 }
 
 
 class EnumListParameter : public MethodParameter {
  public:
   EnumListParameter(const char* name, bool required, const char* const* enums)
-      : MethodParameter(name, required),
-        enums_(enums) {
-  }
+      : MethodParameter(name, required), enums_(enums) {}
 
   virtual bool Validate(const char* value) const {
     return ElementCount(value) >= 0;
   }
 
   const char** Parse(Zone* zone, const char* value_in) const {
     const char* kJsonChars = " \t\r\n[,]";
 
     // Make a writeable copy of the value.
     char* value = zone->MakeCopyOfString(value_in);
@@ skipping 16 matching lines @@
 
       // Advance.  +1 for null terminator.
       value += (len + 1);
     }
     return const_cast<const char**>(elements);
   }
 
  private:
   // For now observatory enums are ascii letters plus underscore.
   static bool IsEnumChar(char c) {
-    return (((c >= 'a') && (c <= 'z')) ||
-            ((c >= 'A') && (c <= 'Z')) ||
+    return (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) ||
             (c == '_'));
   }
 
   // Returns number of elements in the list.  -1 on parse error.
   intptr_t ElementCount(const char* value) const {
     const char* kJsonWhitespaceChars = " \t\r\n";
     if (value == NULL) {
       return -1;
     }
     const char* cp = value;
@@ skipping 60 matching lines @@
   const char* const* enums_;
 };
 
 
 typedef bool (*ServiceMethodEntry)(Thread* thread, JSONStream* js);
 
 
 struct ServiceMethodDescriptor {
   const char* name;
   const ServiceMethodEntry entry;
-  const MethodParameter* const * parameters;
+  const MethodParameter* const* parameters;
 };
 
 
 // TODO(johnmccutchan): Do we reject unexpected parameters?
 static bool ValidateParameters(const MethodParameter* const* parameters,
-                              JSONStream* js) {
+                               JSONStream* js) {
   if (parameters == NULL) {
     return true;
   }
   if (js->NumObjectParameters() > 0) {
     Object& value = Object::Handle();
     for (intptr_t i = 0; parameters[i] != NULL; i++) {
       const MethodParameter* parameter = parameters[i];
       const char* name = parameter->name();
       const bool required = parameter->required();
       value = js->LookupObjectParam(name);
@@ skipping 31 matching lines @@
 void Service::PostError(const String& method_name,
                         const Array& parameter_keys,
                         const Array& parameter_values,
                         const Instance& reply_port,
                         const Instance& id,
                         const Error& error) {
   Thread* T = Thread::Current();
   StackZone zone(T);
   HANDLESCOPE(T);
   JSONStream js;
-  js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-           id, method_name, parameter_keys, parameter_values);
-  js.PrintError(kExtensionError,
-                "Error in extension `%s`: %s",
-                js.method(), error.ToErrorCString());
+  js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(), id, method_name,
+           parameter_keys, parameter_values);
+  js.PrintError(kExtensionError, "Error in extension `%s`: %s", js.method(),
+                error.ToErrorCString());
   js.PostReply();
 }
 
 
 void Service::InvokeMethod(Isolate* I,
                            const Array& msg,
                            bool parameters_are_dart_objects) {
   Thread* T = Thread::Current();
   ASSERT(I == T->isolate());
   ASSERT(I != NULL);
@@ skipping 20 matching lines @@
     ASSERT(seq.IsNull() || seq.IsString() || seq.IsNumber());
     ASSERT(!param_keys.IsNull());
     ASSERT(!param_values.IsNull());
     ASSERT(param_keys.Length() == param_values.Length());
 
     if (!reply_port.IsSendPort()) {
       FATAL("SendPort expected.");
     }
 
     JSONStream js;
-    js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-             seq,
-             method_name,
-             param_keys,
-             param_values,
-             parameters_are_dart_objects);
+    js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(), seq, method_name,
+             param_keys, param_values, parameters_are_dart_objects);
 
     // RPC came in with a custom service id zone.
     const char* id_zone_param = js.LookupParam("_idZone");
 
     if (id_zone_param != NULL) {
       // Override id zone.
       if (strcmp("default", id_zone_param) == 0) {
         // Ring with eager id allocation. This is the default ring and default
         // policy.
         // Nothing to do.
@@ skipping 32 matching lines @@
     EmbedderServiceHandler* handler = FindIsolateEmbedderHandler(c_method_name);
     if (handler == NULL) {
       handler = FindRootEmbedderHandler(c_method_name);
     }
 
     if (handler != NULL) {
       EmbedderHandleMessage(handler, &js);
       return;
     }
 
-    const Instance& extension_handler = Instance::Handle(Z,
-        I->LookupServiceExtensionHandler(method_name));
+    const Instance& extension_handler =
+        Instance::Handle(Z, I->LookupServiceExtensionHandler(method_name));
     if (!extension_handler.IsNull()) {
-      ScheduleExtensionHandler(extension_handler,
-                               method_name,
-                               param_keys,
-                               param_values,
-                               reply_port,
-                               seq);
+      ScheduleExtensionHandler(extension_handler, method_name, param_keys,
+                               param_values, reply_port, seq);
       // Schedule was successful. Extension code will post a reply
       // asynchronously.
       return;
     }
 
     PrintUnrecognizedMethodError(&js);
     js.PostReply();
     return;
   }
 }
@@ skipping 28 matching lines @@
 void Service::SendEvent(const char* stream_id,
                         const char* event_type,
                         uint8_t* bytes,
                         intptr_t bytes_length) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   ASSERT(!ServiceIsolate::IsServiceIsolateDescendant(isolate));
 
   if (FLAG_trace_service) {
-    OS::Print("vm-service: Pushing ServiceEvent(isolate='%s', kind='%s',"
-              " len=%" Pd ") to stream %s\n",
-              isolate->name(), event_type, bytes_length, stream_id);
+    OS::Print(
+        "vm-service: Pushing ServiceEvent(isolate='%s', kind='%s',"
+        " len=%" Pd ") to stream %s\n",
+        isolate->name(), event_type, bytes_length, stream_id);
   }
 
   bool result;
   {
     TransitionVMToNative transition(thread);
     Dart_CObject cbytes;
     cbytes.type = Dart_CObject_kExternalTypedData;
     cbytes.value.as_external_typed_data.type = Dart_TypedData_kUint8;
     cbytes.value.as_external_typed_data.length = bytes_length;
     cbytes.value.as_external_typed_data.data = bytes;
@@ skipping 48 matching lines @@
   memmove(&message[offset], data, data_size);
   offset += data_size;
 
   ASSERT(offset == total_bytes);
   SendEvent(stream_id, event_type, message, total_bytes);
 }
 
 
 static void ReportPauseOnConsole(ServiceEvent* event) {
   const char* name = event->isolate()->debugger_name();
-  switch (event->kind())  {
+  switch (event->kind()) {
     case ServiceEvent::kPauseStart:
       OS::PrintErr(
           "vm-service: isolate '%s' has no debugger attached and is paused at "
-          "start.", name);
+          "start.",
+          name);
       break;
     case ServiceEvent::kPauseExit:
       OS::PrintErr(
           "vm-service: isolate '%s' has no debugger attached and is paused at "
-          "exit.", name);
+          "exit.",
+          name);
       break;
     case ServiceEvent::kPauseException:
       OS::PrintErr(
           "vm-service: isolate '%s' has no debugger attached and is paused due "
-          "to exception.", name);
+          "to exception.",
+          name);
       break;
     case ServiceEvent::kPauseInterrupted:
       OS::PrintErr(
           "vm-service: isolate '%s' has no debugger attached and is paused due "
-          "to interrupt.", name);
+          "to interrupt.",
+          name);
       break;
     case ServiceEvent::kPauseBreakpoint:
       OS::PrintErr(
           "vm-service: isolate '%s' has no debugger attached and is paused.",
           name);
       break;
     case ServiceEvent::kPausePostRequest:
       OS::PrintErr(
           "vm-service: isolate '%s' has no debugger attached and is paused "
-          "post reload.", name);
+          "post reload.",
+          name);
       break;
     default:
       UNREACHABLE();
       break;
   }
   if (!ServiceIsolate::IsRunning()) {
     OS::PrintErr("  Start the vm-service to debug.\n");
   } else if (ServiceIsolate::server_address() == NULL) {
     OS::PrintErr("  Connect to Observatory to debug.\n");
   } else {
     OS::PrintErr("  Connect to Observatory at %s to debug.\n",
                  ServiceIsolate::server_address());
   }
   const Error& err = Error::Handle(Thread::Current()->sticky_error());
   if (!err.IsNull()) {
     OS::PrintErr("%s\n", err.ToErrorCString());
   }
 }
 
 
 void Service::HandleEvent(ServiceEvent* event) {
-  if (event->stream_info() != NULL &&
-      !event->stream_info()->enabled()) {
-    if (FLAG_warn_on_pause_with_no_debugger &&
-        event->IsPause()) {
+  if (event->stream_info() != NULL && !event->stream_info()->enabled()) {
+    if (FLAG_warn_on_pause_with_no_debugger && event->IsPause()) {
       // If we are about to pause a running program which has no
       // debugger connected, tell the user about it.
       ReportPauseOnConsole(event);
     }
     // Ignore events when no one is listening to the event stream.
     return;
   }
   if (!ServiceIsolate::IsRunning()) {
     return;
   }
@@ skipping 39 matching lines @@
   Dart_CObject json_cobj;
   json_cobj.type = Dart_CObject_kString;
   json_cobj.value.as_string = const_cast<char*>(event->ToCString());
   list_values[1] = &json_cobj;
 
   if (FLAG_trace_service) {
     const char* isolate_name = "<no current isolate>";
     if (isolate != NULL) {
       isolate_name = isolate->name();
     }
-    OS::Print("vm-service: Pushing ServiceEvent(isolate='%s', kind='%s') "
-              "to stream %s\n",
-              isolate_name, kind, stream_id);
+    OS::Print(
+        "vm-service: Pushing ServiceEvent(isolate='%s', kind='%s') "
+        "to stream %s\n",
+        isolate_name, kind, stream_id);
   }
 
   Dart_PostCObject(ServiceIsolate::Port(), &list_cobj);
 }
 
 
 class EmbedderServiceHandler {
  public:
-  explicit EmbedderServiceHandler(const char* name) : name_(NULL),
-                                                      callback_(NULL),
-                                                      user_data_(NULL),
-                                                      next_(NULL) {
+  explicit EmbedderServiceHandler(const char* name)
+      : name_(NULL), callback_(NULL), user_data_(NULL), next_(NULL) {
     ASSERT(name != NULL);
     name_ = strdup(name);
   }
 
-  ~EmbedderServiceHandler() {
-    free(name_);
-  }
+  ~EmbedderServiceHandler() { free(name_); }
 
   const char* name() const { return name_; }
 
   Dart_ServiceRequestCallback callback() const { return callback_; }
   void set_callback(Dart_ServiceRequestCallback callback) {
     callback_ = callback;
   }
 
   void* user_data() const { return user_data_; }
-  void set_user_data(void* user_data) {
-    user_data_ = user_data;
-  }
+  void set_user_data(void* user_data) { user_data_ = user_data; }
 
   EmbedderServiceHandler* next() const { return next_; }
-  void set_next(EmbedderServiceHandler* next) {
-    next_ = next;
-  }
+  void set_next(EmbedderServiceHandler* next) { next_ = next; }
 
  private:
   char* name_;
   Dart_ServiceRequestCallback callback_;
   void* user_data_;
   EmbedderServiceHandler* next_;
 };
 
 
 void Service::EmbedderHandleMessage(EmbedderServiceHandler* handler,
@@ skipping 36 matching lines @@
   handler = new EmbedderServiceHandler(name);
   handler->set_callback(callback);
   handler->set_user_data(user_data);
 
   // Insert into isolate_service_handler_head_ list.
   handler->set_next(isolate_service_handler_head_);
   isolate_service_handler_head_ = handler;
 }
 
 
-EmbedderServiceHandler* Service::FindIsolateEmbedderHandler(
-    const char* name) {
+EmbedderServiceHandler* Service::FindIsolateEmbedderHandler(const char* name) {
   EmbedderServiceHandler* current = isolate_service_handler_head_;
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 
-void Service::RegisterRootEmbedderCallback(
-    const char* name,
-    Dart_ServiceRequestCallback callback,
-    void* user_data) {
+void Service::RegisterRootEmbedderCallback(const char* name,
+                                           Dart_ServiceRequestCallback callback,
+                                           void* user_data) {
   if (name == NULL) {
     return;
   }
   EmbedderServiceHandler* handler = FindRootEmbedderHandler(name);
   if (handler != NULL) {
     // Update existing handler entry.
     handler->set_callback(callback);
     handler->set_user_data(user_data);
     return;
   }
@@ skipping 15 matching lines @@
   stream_cancel_callback_ = cancel_callback;
 }
 
 
 void Service::SetGetServiceAssetsCallback(
     Dart_GetVMServiceAssetsArchive get_service_assets) {
   get_service_assets_callback_ = get_service_assets;
 }
 
 
-EmbedderServiceHandler* Service::FindRootEmbedderHandler(
-    const char* name) {
+EmbedderServiceHandler* Service::FindRootEmbedderHandler(const char* name) {
   EmbedderServiceHandler* current = root_service_handler_head_;
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 
 void Service::ScheduleExtensionHandler(const Instance& handler,
                                        const String& method_name,
                                        const Array& parameter_keys,
                                        const Array& parameter_values,
                                        const Instance& reply_port,
                                        const Instance& id) {
   ASSERT(!handler.IsNull());
   ASSERT(!method_name.IsNull());
   ASSERT(!parameter_keys.IsNull());
   ASSERT(!parameter_values.IsNull());
   ASSERT(!reply_port.IsNull());
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
-  isolate->AppendServiceExtensionCall(handler,
-                                      method_name,
-                                      parameter_keys,
-                                      parameter_values,
-                                      reply_port,
-                                      id);
+  isolate->AppendServiceExtensionCall(handler, method_name, parameter_keys,
+                                      parameter_values, reply_port, id);
 }
 
 
 static const MethodParameter* get_isolate_params[] = {
-  ISOLATE_PARAMETER,
-  NULL,
+    ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetIsolate(Thread* thread, JSONStream* js) {
   thread->isolate()->PrintJSON(js, false);
   return true;
 }
 
 
 static const MethodParameter* get_stack_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new BoolParameter("_full", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new BoolParameter("_full", false), NULL,
 };
 
 
 static bool GetStack(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   if (isolate->debugger() == NULL) {
     js->PrintError(kFeatureDisabled,
                    "Cannot get stack when debugger disabled.");
     return true;
   }
@@ skipping 49 matching lines @@
         event.AddProperty("kind", "_Echo");
         event.AddProperty("isolate", isolate);
         if (text != NULL) {
           event.AddProperty("text", text);
         }
         event.AddPropertyTimeMillis("timestamp", OS::GetCurrentTimeMillis());
       }
     }
   }
   uint8_t data[] = {0, 128, 255};
-  SendEventWithData(echo_stream.id(), "_Echo",
-                    js.buffer()->buf(), js.buffer()->length(),
-                    data, sizeof(data));
+  SendEventWithData(echo_stream.id(), "_Echo", js.buffer()->buf(),
+                    js.buffer()->length(), data, sizeof(data));
 }
 
 
 static bool TriggerEchoEvent(Thread* thread, JSONStream* js) {
   if (Service::echo_stream.enabled()) {
     Service::SendEchoEvent(thread->isolate(), js->LookupParam("text"));
   }
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
@@ skipping 47 matching lines @@
 }
 
 
 static RawObject* LookupObjectId(Thread* thread,
                                  const char* arg,
                                  ObjectIdRing::LookupResult* kind) {
   *kind = ObjectIdRing::kValid;
   if (strncmp(arg, "int-", 4) == 0) {
     arg += 4;
     int64_t value = 0;
-    if (!OS::StringToInt64(arg, &value) ||
-        !Smi::IsValid(value)) {
+    if (!OS::StringToInt64(arg, &value) || !Smi::IsValid(value)) {
       *kind = ObjectIdRing::kInvalid;
       return Object::null();
     }
-    const Integer& obj = Integer::Handle(thread->zone(),
-        Smi::New(static_cast<intptr_t>(value)));
+    const Integer& obj =
+        Integer::Handle(thread->zone(), Smi::New(static_cast<intptr_t>(value)));
     return obj.raw();
   } else if (strcmp(arg, "bool-true") == 0) {
     return Bool::True().raw();
   } else if (strcmp(arg, "bool-false") == 0) {
     return Bool::False().raw();
   } else if (strcmp(arg, "null") == 0) {
     return Object::null();
   }
 
   ObjectIdRing* ring = thread->isolate()->object_id_ring();
   ASSERT(ring != NULL);
   intptr_t id = -1;
   if (!GetIntegerId(arg, &id)) {
     *kind = ObjectIdRing::kInvalid;
     return Object::null();
   }
   return ring->GetObjectForId(id, kind);
 }
 
 
 static RawObject* LookupHeapObjectLibraries(Isolate* isolate,
-                                            char** parts, int num_parts) {
+                                            char** parts,
+                                            int num_parts) {
   // Library ids look like "libraries/35"
   if (num_parts < 2) {
     return Object::sentinel().raw();
   }
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
   ASSERT(!libs.IsNull());
   intptr_t id = 0;
   if (!GetIntegerId(parts[1], &id)) {
     return Object::sentinel().raw();
@@ skipping 37 matching lines @@
         return script.raw();
       }
     }
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 static RawObject* LookupHeapObjectClasses(Thread* thread,
-                                          char** parts, int num_parts) {
+                                          char** parts,
+                                          int num_parts) {
   // Class ids look like: "classes/17"
   if (num_parts < 2) {
     return Object::sentinel().raw();
   }
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   ClassTable* table = isolate->class_table();
   intptr_t id;
-  if (!GetIntegerId(parts[1], &id) ||
-      !table->IsValidIndex(id)) {
+  if (!GetIntegerId(parts[1], &id) || !table->IsValidIndex(id)) {
     return Object::sentinel().raw();
   }
   Class& cls = Class::Handle(zone, table->At(id));
   if (num_parts == 2) {
     return cls.raw();
   }
   if (strcmp(parts[2], "closures") == 0) {
     // Closure ids look like: "classes/17/closures/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
@@ skipping 92 matching lines @@
       return type.raw();
     }
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
 static RawObject* LookupHeapObjectTypeArguments(Thread* thread,
-                                                char** parts, int num_parts) {
+                                                char** parts,
+                                                int num_parts) {
   Isolate* isolate = thread->isolate();
   // TypeArguments ids look like: "typearguments/17"
   if (num_parts < 2) {
     return Object::sentinel().raw();
   }
   intptr_t id;
   if (!GetIntegerId(parts[1], &id)) {
     return Object::sentinel().raw();
   }
   ObjectStore* object_store = isolate->object_store();
-  const Array& table = Array::Handle(thread->zone(),
-                                     object_store->canonical_type_arguments());
+  const Array& table =
+      Array::Handle(thread->zone(), object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   const intptr_t table_size = table.Length() - 1;
   if ((id < 0) || (id >= table_size) || (table.At(id) == Object::null())) {
     return Object::sentinel().raw();
   }
   return table.At(id);
 }
 
 
 static RawObject* LookupHeapObjectCode(Isolate* isolate,
-                                       char** parts, int num_parts) {
+                                       char** parts,
+                                       int num_parts) {
   if (num_parts != 2) {
     return Object::sentinel().raw();
   }
   uword pc;
   static const char* const kCollectedPrefix = "collected-";
   static intptr_t kCollectedPrefixLen = strlen(kCollectedPrefix);
   static const char* const kNativePrefix = "native-";
   static const intptr_t kNativePrefixLen = strlen(kNativePrefix);
   static const char* const kReusedPrefix = "reused-";
   static const intptr_t kReusedPrefixLen = strlen(kReusedPrefix);
@@ skipping 27 matching lines @@
   if (!code.IsNull()) {
     return code.raw();
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
 static RawObject* LookupHeapObjectMessage(Thread* thread,
-                                          char** parts, int num_parts) {
+                                          char** parts,
+                                          int num_parts) {
   if (num_parts != 2) {
     return Object::sentinel().raw();
   }
   uword message_id = 0;
   if (!GetUnsignedIntegerId(parts[1], &message_id, 16)) {
     return Object::sentinel().raw();
   }
   MessageHandler::AcquiredQueues aq(thread->isolate()->message_handler());
   Message* message = aq.queue()->FindMessageById(message_id);
   if (message == NULL) {
     // The user may try to load an expired message.
     return Object::sentinel().raw();
   }
   if (message->len() > 0) {
-    MessageSnapshotReader reader(message->data(),
-                                 message->len(),
-                                 thread);
+    MessageSnapshotReader reader(message->data(), message->len(), thread);
     return reader.ReadObject();
   } else {
     return message->raw_obj();
   }
 }
 
 
 static RawObject* LookupHeapObject(Thread* thread,
                                    const char* id_original,
                                    ObjectIdRing::LookupResult* result) {
@@ skipping 131 matching lines @@
     Field& field = Field::Handle();
     Array& parent_field_map = Array::Handle();
     limit = Utils::Minimum(limit, length);
     for (intptr_t i = 0; i < limit; ++i) {
       JSONObject jselement(&elements);
       source = path.At(i * 2);
       slot_offset ^= path.At((i * 2) + 1);
 
       jselement.AddProperty("source", source);
       if (source.IsArray()) {
-        intptr_t element_index = slot_offset.Value() -
-            (Array::element_offset(0) >> kWordSizeLog2);
+        intptr_t element_index =
+            slot_offset.Value() - (Array::element_offset(0) >> kWordSizeLog2);
         jselement.AddProperty("parentListIndex", element_index);
       } else if (source.IsInstance()) {
         source_class ^= source.clazz();
         parent_field_map = source_class.OffsetToFieldMap();
         intptr_t offset = slot_offset.Value();
         if (offset > 0 && offset < parent_field_map.Length()) {
           field ^= parent_field_map.At(offset);
           jselement.AddProperty("parentField", field);
         }
       } else {
         intptr_t element_index = slot_offset.Value();
         jselement.AddProperty("_parentWordOffset", element_index);
       }
     }
   }
 
   // We nil out the array after generating the response to prevent
   // reporting suprious references when repeatedly looking for the
   // references to an object.
   for (intptr_t i = 0; i < path.Length(); i++) {
     path.SetAt(i, Object::null_object());
   }
 
   return true;
 }
 
 
 static const MethodParameter* get_inbound_references_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetInboundReferences(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* limit_cstr = js->LookupParam("limit");
@@ skipping 49 matching lines @@
   for (intptr_t i = 0; i < limit; ++i) {
     JSONObject jselement(&elements);
     element = path.At(i * 2);
     jselement.AddProperty("value", element);
     // Interpret the word offset from parent as list index, map key
     // or instance field.
     if (i > 0) {
       slot_offset ^= path.At((i * 2) - 1);
       jselement.AddProperty("offset", slot_offset.Value());
       if (element.IsArray() || element.IsGrowableObjectArray()) {
-        intptr_t element_index = slot_offset.Value() -
-            (Array::element_offset(0) >> kWordSizeLog2);
+        intptr_t element_index =
+            slot_offset.Value() - (Array::element_offset(0) >> kWordSizeLog2);
         jselement.AddProperty("parentListIndex", element_index);
       } else if (element.IsLinkedHashMap()) {
         map = static_cast<RawLinkedHashMap*>(path.At(i * 2));
         map_data = map.data();
-        intptr_t element_index = slot_offset.Value() -
-            (Array::element_offset(0) >> kWordSizeLog2);
+        intptr_t element_index =
+            slot_offset.Value() - (Array::element_offset(0) >> kWordSizeLog2);
         LinkedHashMap::Iterator iterator(map);
         while (iterator.MoveNext()) {
           if (iterator.CurrentKey() == map_data.At(element_index) ||
               iterator.CurrentValue() == map_data.At(element_index)) {
             element = iterator.CurrentKey();
             jselement.AddProperty("parentMapKey", element);
             break;
           }
         }
       } else if (element.IsInstance()) {
@@ skipping 16 matching lines @@
   // after looking for a retaining path.
   for (intptr_t i = 0; i < path.Length(); i++) {
     path.SetAt(i, Object::null_object());
   }
 
   return true;
 }
 
 
 static const MethodParameter* get_retaining_path_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetRetainingPath(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* limit_cstr = js->LookupParam("limit");
@@ skipping 21 matching lines @@
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
   return PrintRetainingPath(thread, &obj, limit, js);
 }
 
 
 static const MethodParameter* get_retained_size_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("targetId", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new IdParameter("targetId", true), NULL,
 };
 
 
 static bool GetRetainedSize(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   ASSERT(target_id != NULL);
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(LookupHeapObject(thread, target_id,
-                                                &lookup_result));
+  Object& obj =
+      Object::Handle(LookupHeapObject(thread, target_id, &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
@@ skipping 10 matching lines @@
 
   ObjectGraph graph(thread);
   intptr_t retained_size = graph.SizeRetainedByInstance(obj);
   const Object& result = Object::Handle(Integer::New(retained_size));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 static const MethodParameter* get_reachable_size_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("targetId", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new IdParameter("targetId", true), NULL,
 };
 
 
 static bool GetReachableSize(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   ASSERT(target_id != NULL);
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(LookupHeapObject(thread, target_id,
-                                                &lookup_result));
+  Object& obj =
+      Object::Handle(LookupHeapObject(thread, target_id, &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
@@ skipping 10 matching lines @@
 
   ObjectGraph graph(thread);
   intptr_t retained_size = graph.SizeReachableByInstance(obj);
   const Object& result = Object::Handle(Integer::New(retained_size));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 static const MethodParameter* evaluate_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool Evaluate(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
                    "Cannot evaluate when running a precompiled program.");
     return true;
   }
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* expr = js->LookupParam("expression");
   if (expr == NULL) {
     PrintMissingParamError(js, "expression");
     return true;
   }
   Zone* zone = thread->zone();
   const String& expr_str = String::Handle(zone, String::New(expr));
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(zone, LookupHeapObject(thread, target_id,
-                                                      &lookup_result));
+  Object& obj =
+      Object::Handle(zone, LookupHeapObject(thread, target_id, &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
   if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
-    const Object& result = Object::Handle(zone,
+    const Object& result = Object::Handle(
+        zone,
         lib.Evaluate(expr_str, Array::empty_array(), Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    const Object& result = Object::Handle(zone,
+    const Object& result = Object::Handle(
+        zone,
         cls.Evaluate(expr_str, Array::empty_array(), Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
-  if ((obj.IsInstance() || obj.IsNull()) &&
-      !ContainsNonInstance(obj)) {
+  if ((obj.IsInstance() || obj.IsNull()) && !ContainsNonInstance(obj)) {
     // We don't use Instance::Cast here because it doesn't allow null.
     Instance& instance = Instance::Handle(zone);
     instance ^= obj.raw();
     const Class& receiver_cls = Class::Handle(zone, instance.clazz());
-    const Object& result =
-        Object::Handle(zone, instance.Evaluate(receiver_cls,
-                                               expr_str,
-                                               Array::empty_array(),
-                                               Array::empty_array()));
+    const Object& result = Object::Handle(
+        zone, instance.Evaluate(receiver_cls, expr_str, Array::empty_array(),
+                                Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
   js->PrintError(kInvalidParams,
                  "%s: invalid 'targetId' parameter: "
-                 "Cannot evaluate against a VM-internal object", js->method());
+                 "Cannot evaluate against a VM-internal object",
+                 js->method());
   return true;
 }
 
 
 static const MethodParameter* evaluate_in_frame_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new UIntParameter("frameIndex", true),
-  new MethodParameter("expression", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new UIntParameter("frameIndex", true),
+    new MethodParameter("expression", true), NULL,
 };
 
 
 static bool EvaluateInFrame(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   if (!isolate->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
                    "Cannot evaluate when running a precompiled program.");
     return true;
   }
@@ skipping 41 matching lines @@
   intptr_t count() const { return count_; }
 
  private:
   const Class& cls_;
   const Array& storage_;
   intptr_t count_;
 };
 
 
 static const MethodParameter* get_instances_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetInstances(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("classId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "classId");
     return true;
   }
   const char* limit_cstr = js->LookupParam("limit");
   if (limit_cstr == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
   if (!GetIntegerId(limit_cstr, &limit)) {
     PrintInvalidParamError(js, "limit");
     return true;
   }
-  const Object& obj =
-      Object::Handle(LookupHeapObject(thread, target_id, NULL));
-  if (obj.raw() == Object::sentinel().raw() ||
-      !obj.IsClass()) {
+  const Object& obj = Object::Handle(LookupHeapObject(thread, target_id, NULL));
+  if (obj.raw() == Object::sentinel().raw() || !obj.IsClass()) {
     PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Cast(obj);
   Array& storage = Array::Handle(Array::New(limit));
   GetInstancesVisitor visitor(cls, storage);
   ObjectGraph graph(thread);
   graph.IterateObjects(&visitor);
   intptr_t count = visitor.count();
   JSONObject jsobj(js);
@@ skipping 12 matching lines @@
   // after looking at allInstances.
   for (intptr_t i = 0; i < storage.Length(); i++) {
     storage.SetAt(i, Object::null_object());
   }
 
   return true;
 }
 
 
 static const char* const report_enum_names[] = {
-  SourceReport::kCallSitesStr,
-  SourceReport::kCoverageStr,
-  SourceReport::kPossibleBreakpointsStr,
-  SourceReport::kProfileStr,
-  NULL,
+    SourceReport::kCallSitesStr,
+    SourceReport::kCoverageStr,
+    SourceReport::kPossibleBreakpointsStr,
+    SourceReport::kProfileStr,
+    NULL,
 };
 
 
 static const MethodParameter* get_source_report_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new EnumListParameter("reports", true, report_enum_names),
-  new IdParameter("scriptId", false),
-  new UIntParameter("tokenPos", false),
-  new UIntParameter("endTokenPos", false),
-  new BoolParameter("forceCompile", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new EnumListParameter("reports", true, report_enum_names),
+    new IdParameter("scriptId", false),
+    new UIntParameter("tokenPos", false),
+    new UIntParameter("endTokenPos", false),
+    new BoolParameter("forceCompile", false),
+    NULL,
 };
 
 
 static bool GetSourceReport(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot get source report when running a precompiled program.");
     return true;
   }
   const char* reports_str = js->LookupParam("reports");
   const EnumListParameter* reports_parameter =
       static_cast<const EnumListParameter*>(get_source_report_params[1]);
   const char** reports = reports_parameter->Parse(thread->zone(), reports_str);
   intptr_t report_set = 0;
   while (*reports != NULL) {
     if (strcmp(*reports, SourceReport::kCallSitesStr) == 0) {
@@ skipping 37 matching lines @@
     }
     if (js->HasParam("endTokenPos")) {
       js->PrintError(
           kInvalidParams,
           "%s: the 'endTokenPos' parameter requires the 'scriptId' parameter",
           js->method());
       return true;
     }
   }
   SourceReport report(report_set, compile_mode);
-  report.PrintJSON(js,
-                   script,
-                   TokenPosition(start_pos),
+  report.PrintJSON(js, script, TokenPosition(start_pos),
                    TokenPosition(end_pos));
   return true;
 }
 
 
 static const MethodParameter* reload_sources_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new BoolParameter("force", false),
-  new BoolParameter("pause", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new BoolParameter("force", false),
+    new BoolParameter("pause", false), NULL,
 };
 
 
 static bool ReloadSources(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   if (!isolate->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
-        "Cannot reload source when running a precompiled program.");
+                   "Cannot reload source when running a precompiled program.");
     return true;
   }
   if (Dart::snapshot_kind() == Snapshot::kAppWithJIT) {
     js->PrintError(kFeatureDisabled,
-        "Cannot reload source when running an app snapshot.");
+                   "Cannot reload source when running an app snapshot.");
     return true;
   }
   Dart_LibraryTagHandler handler = isolate->library_tag_handler();
   if (handler == NULL) {
     js->PrintError(kFeatureDisabled,
                    "A library tag handler must be installed.");
     return true;
   }
   if ((isolate->sticky_error() != Error::null()) ||
       (Thread::Current()->sticky_error() != Error::null())) {
     js->PrintError(kIsolateReloadBarred,
                    "This isolate cannot reload sources anymore because there "
                    "was an unhandled exception error. Restart the isolate.");
     return true;
   }
   if (isolate->IsReloading()) {
-    js->PrintError(kIsolateIsReloading,
-                   "This isolate is being reloaded.");
+    js->PrintError(kIsolateIsReloading, "This isolate is being reloaded.");
     return true;
   }
   if (!isolate->CanReload()) {
     js->PrintError(kFeatureDisabled,
                    "This isolate cannot reload sources right now.");
     return true;
   }
   const bool force_reload =
       BoolParameter::Parse(js->LookupParam("force"), false);
 
@@ skipping 20 matching lines @@
       isolate->PausePostRequest();
     }
   }
 }
 
 
 static bool AddBreakpointCommon(Thread* thread,
                                 JSONStream* js,
                                 const String& script_uri) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* line_param = js->LookupParam("line");
   intptr_t line = UIntParameter::Parse(line_param);
   const char* col_param = js->LookupParam("column");
   intptr_t col = -1;
   if (col_param != NULL) {
     col = UIntParameter::Parse(col_param);
     if (col == 0) {
       // Column number is 1-based.
       PrintInvalidParamError(js, "column");
       return true;
     }
   }
   ASSERT(!script_uri.IsNull());
   Breakpoint* bpt = NULL;
-  bpt = thread->isolate()->debugger()->
-      SetBreakpointAtLineCol(script_uri, line, col);
+  bpt = thread->isolate()->debugger()->SetBreakpointAtLineCol(script_uri, line,
+                                                              col);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
-                   "%s: Cannot add breakpoint at line '%s'",
-                   js->method(), line_param);
+                   "%s: Cannot add breakpoint at line '%s'", js->method(),
+                   line_param);
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* add_breakpoint_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("scriptId", true),
-  new UIntParameter("line", true),
-  new UIntParameter("column", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new IdParameter("scriptId", true),
+    new UIntParameter("line", true),
+    new UIntParameter("column", false),
+    NULL,
 };
 
 
 static bool AddBreakpoint(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* script_id_param = js->LookupParam("scriptId");
   Object& obj = Object::Handle(LookupHeapObject(thread, script_id_param, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsScript()) {
     PrintInvalidParamError(js, "scriptId");
     return true;
   }
   const Script& script = Script::Cast(obj);
   const String& script_uri = String::Handle(script.url());
   ASSERT(!script_uri.IsNull());
   return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_with_script_uri_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("scriptUri", true),
-  new UIntParameter("line", true),
-  new UIntParameter("column", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new IdParameter("scriptUri", true),
+    new UIntParameter("line", true),
+    new UIntParameter("column", false),
+    NULL,
 };
 
 
 static bool AddBreakpointWithScriptUri(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* script_uri_param = js->LookupParam("scriptUri");
   const String& script_uri = String::Handle(String::New(script_uri_param));
   return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_at_entry_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("functionId", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new IdParameter("functionId", true), NULL,
 };
 
 
 static bool AddBreakpointAtEntry(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* function_id = js->LookupParam("functionId");
   Object& obj = Object::Handle(LookupHeapObject(thread, function_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsFunction()) {
     PrintInvalidParamError(js, "functionId");
     return true;
   }
   const Function& function = Function::Cast(obj);
   Breakpoint* bpt =
       thread->isolate()->debugger()->SetBreakpointAtEntry(function, false);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
-                   "%s: Cannot add breakpoint at function '%s'",
-                   js->method(), function.ToCString());
+                   "%s: Cannot add breakpoint at function '%s'", js->method(),
+                   function.ToCString());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* add_breakpoint_at_activation_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("objectId", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new IdParameter("objectId", true), NULL,
 };
 
 
 static bool AddBreakpointAtActivation(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* object_id = js->LookupParam("objectId");
   Object& obj = Object::Handle(LookupHeapObject(thread, object_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsInstance()) {
     PrintInvalidParamError(js, "objectId");
     return true;
   }
   const Instance& closure = Instance::Cast(obj);
   Breakpoint* bpt =
       thread->isolate()->debugger()->SetBreakpointAtActivation(closure, false);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
-                   "%s: Cannot add breakpoint at activation",
-                   js->method());
+                   "%s: Cannot add breakpoint at activation", js->method());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* remove_breakpoint_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool RemoveBreakpoint(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   if (!js->HasParam("breakpointId")) {
     PrintMissingParamError(js, "breakpointId");
     return true;
   }
   const char* bpt_id = js->LookupParam("breakpointId");
   ObjectIdRing::LookupResult lookup_result;
   Isolate* isolate = thread->isolate();
   Breakpoint* bpt = LookupBreakpoint(isolate, bpt_id, &lookup_result);
   // TODO(turnidge): Should we return a different error for bpts whic
   // have been already removed?
   if (bpt == NULL) {
     PrintInvalidParamError(js, "breakpointId");
     return true;
   }
   isolate->debugger()->RemoveBreakpoint(bpt->id());
   PrintSuccess(js);
   return true;
 }
 
 
 static RawClass* GetMetricsClass(Thread* thread) {
   Zone* zone = thread->zone();
-  const Library& prof_lib =
-      Library::Handle(zone, Library::DeveloperLibrary());
+  const Library& prof_lib = Library::Handle(zone, Library::DeveloperLibrary());
   ASSERT(!prof_lib.IsNull());
-  const String& metrics_cls_name =
-      String::Handle(zone, String::New("Metrics"));
+  const String& metrics_cls_name = String::Handle(zone, String::New("Metrics"));
   ASSERT(!metrics_cls_name.IsNull());
   const Class& metrics_cls =
       Class::Handle(zone, prof_lib.LookupClass(metrics_cls_name));
   ASSERT(!metrics_cls.IsNull());
   return metrics_cls.raw();
 }
 
 
-
 static bool HandleNativeMetricsList(Thread* thread, JSONStream* js) {
   JSONObject obj(js);
   obj.AddProperty("type", "MetricList");
   {
     JSONArray metrics(&obj, "metrics");
     Metric* current = thread->isolate()->metrics_list_head();
     while (current != NULL) {
       metrics.AddValue(current);
       current = current->next();
     }
@@ skipping 13 matching lines @@
     }
     current = current->next();
   }
   PrintInvalidParamError(js, "metricId");
   return true;
 }
 
 
 static bool HandleDartMetricsList(Thread* thread, JSONStream* js) {
   Zone* zone = thread->zone();
-  const Class& metrics_cls =
-      Class::Handle(zone, GetMetricsClass(thread));
+  const Class& metrics_cls = Class::Handle(zone, GetMetricsClass(thread));
   const String& print_metrics_name =
       String::Handle(String::New("_printMetrics"));
   ASSERT(!print_metrics_name.IsNull());
   const Function& print_metrics = Function::Handle(
-      zone,
-      metrics_cls.LookupStaticFunctionAllowPrivate(print_metrics_name));
+      zone, metrics_cls.LookupStaticFunctionAllowPrivate(print_metrics_name));
   ASSERT(!print_metrics.IsNull());
   const Array& args = Object::empty_array();
   const Object& result =
       Object::Handle(zone, DartEntry::InvokeFunction(print_metrics, args));
   ASSERT(!result.IsNull());
   ASSERT(result.IsString());
   TextBuffer* buffer = js->buffer();
   buffer->AddString(String::Cast(result).ToCString());
   return true;
 }
 
 
 static bool HandleDartMetric(Thread* thread, JSONStream* js, const char* id) {
   Zone* zone = thread->zone();
-  const Class& metrics_cls =
-      Class::Handle(zone, GetMetricsClass(thread));
-  const String& print_metric_name =
-      String::Handle(String::New("_printMetric"));
+  const Class& metrics_cls = Class::Handle(zone, GetMetricsClass(thread));
+  const String& print_metric_name = String::Handle(String::New("_printMetric"));
   ASSERT(!print_metric_name.IsNull());
   const Function& print_metric = Function::Handle(
-      zone,
-      metrics_cls.LookupStaticFunctionAllowPrivate(print_metric_name));
+      zone, metrics_cls.LookupStaticFunctionAllowPrivate(print_metric_name));
   ASSERT(!print_metric.IsNull());
   const String& arg0 = String::Handle(String::New(id));
   ASSERT(!arg0.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   ASSERT(!args.IsNull());
   args.SetAt(0, arg0);
   const Object& result =
       Object::Handle(zone, DartEntry::InvokeFunction(print_metric, args));
   if (!result.IsNull()) {
     ASSERT(result.IsString());
     TextBuffer* buffer = js->buffer();
     buffer->AddString(String::Cast(result).ToCString());
     return true;
   }
   PrintInvalidParamError(js, "metricId");
   return true;
 }
 
 
 static const MethodParameter* get_isolate_metric_list_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetIsolateMetricList(Thread* thread, JSONStream* js) {
   bool native_metrics = false;
   if (js->HasParam("type")) {
     if (js->ParamIs("type", "Native")) {
       native_metrics = true;
     } else if (js->ParamIs("type", "Dart")) {
       native_metrics = false;
     } else {
       PrintInvalidParamError(js, "type");
       return true;
     }
   } else {
     PrintMissingParamError(js, "type");
     return true;
   }
   if (native_metrics) {
     return HandleNativeMetricsList(thread, js);
   }
   return HandleDartMetricsList(thread, js);
 }
 
 
 static const MethodParameter* get_isolate_metric_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetIsolateMetric(Thread* thread, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
     return true;
   }
   // Verify id begins with "metrics/".
@@ skipping 11 matching lines @@
   if (native_metric) {
     const char* id = metric_id + kNativeMetricIdPrefixLen;
     return HandleNativeMetric(thread, js, id);
   }
   const char* id = metric_id + kMetricIdPrefixLen;
   return HandleDartMetric(thread, js, id);
 }
 
 
 static const MethodParameter* get_vm_metric_list_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetVMMetricList(Thread* thread, JSONStream* js) {
   return false;
 }
 
 
 static const MethodParameter* get_vm_metric_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetVMMetric(Thread* thread, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
   }
   return false;
 }
 
 static const char* const timeline_streams_enum_names[] = {
-  "all",
-#define DEFINE_NAME(name, unused)                                              \
-  #name,
-TIMELINE_STREAM_LIST(DEFINE_NAME)
+    "all",
+#define DEFINE_NAME(name, unused) #name,
+    TIMELINE_STREAM_LIST(DEFINE_NAME)
 #undef DEFINE_NAME
-  NULL
-};
+        NULL};
 
 static const MethodParameter* set_vm_timeline_flags_params[] = {
-  NO_ISOLATE_PARAMETER,
-  new EnumListParameter("recordedStreams",
-                        false,
-                        timeline_streams_enum_names),
-  NULL,
+    NO_ISOLATE_PARAMETER, new EnumListParameter("recordedStreams",
+                                                false,
+                                                timeline_streams_enum_names),
+    NULL,
 };
 
 
 static bool HasStream(const char** recorded_streams, const char* stream) {
   while (*recorded_streams != NULL) {
     if ((strstr(*recorded_streams, "all") != NULL) ||
         (strstr(*recorded_streams, stream) != NULL)) {
       return true;
     }
     recorded_streams++;
@@ skipping 13 matching lines @@
 
   const EnumListParameter* recorded_streams_param =
       static_cast<const EnumListParameter*>(set_vm_timeline_flags_params[1]);
 
   const char* recorded_streams_str = js->LookupParam("recordedStreams");
   const char** recorded_streams =
       recorded_streams_param->Parse(thread->zone(), recorded_streams_str);
 
 #define SET_ENABLE_STREAM(name, unused)                                        \
   Timeline::SetStream##name##Enabled(HasStream(recorded_streams, #name));
-TIMELINE_STREAM_LIST(SET_ENABLE_STREAM);
+  TIMELINE_STREAM_LIST(SET_ENABLE_STREAM);
 #undef SET_ENABLE_STREAM
 
   PrintSuccess(js);
 
   return true;
 }
 
 
 static const MethodParameter* get_vm_timeline_flags_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetVMTimelineFlags(Thread* thread, JSONStream* js) {
   if (!FLAG_support_timeline) {
     JSONObject obj(js);
     obj.AddProperty("type", "TimelineFlags");
     return true;
   }
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   StackZone zone(thread);
   Timeline::PrintFlagsToJSON(js);
   return true;
 }
 
 
 static const MethodParameter* clear_vm_timeline_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool ClearVMTimeline(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   StackZone zone(thread);
 
   Timeline::Clear();
 
   PrintSuccess(js);
 
   return true;
 }
 
 
 static const MethodParameter* get_vm_timeline_params[] = {
-  NO_ISOLATE_PARAMETER,
-  new Int64Parameter("timeOriginMicros", false),
-  new Int64Parameter("timeExtentMicros", false),
-  NULL,
+    NO_ISOLATE_PARAMETER, new Int64Parameter("timeOriginMicros", false),
+    new Int64Parameter("timeExtentMicros", false), NULL,
 };
 
 
 static bool GetVMTimeline(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   StackZone zone(thread);
   Timeline::ReclaimCachedBlocksFromThreads();
   TimelineEventRecorder* timeline_recorder = Timeline::recorder();
   // TODO(johnmccutchan): Return an error.
   ASSERT(timeline_recorder != NULL);
   int64_t time_origin_micros =
       Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
   int64_t time_extent_micros =
       Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
   TimelineEventFilter filter(time_origin_micros, time_extent_micros);
   timeline_recorder->PrintJSON(js, &filter);
   return true;
 }
 
 
 static const MethodParameter* resume_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool Resume(Thread* thread, JSONStream* js) {
   const char* step_param = js->LookupParam("step");
   Isolate* isolate = thread->isolate();
   if (isolate->message_handler()->is_paused_on_start()) {
     // If the user is issuing a 'Over' or an 'Out' step, that is the
     // same as a regular resume request.
     if ((step_param != NULL) && (strcmp(step_param, "Into") == 0)) {
@@ skipping 48 matching lines @@
     PrintSuccess(js);
     return true;
   }
 
   js->PrintError(kIsolateMustBePaused, NULL);
   return true;
 }
 
 
 static const MethodParameter* pause_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool Pause(Thread* thread, JSONStream* js) {
   // TODO(turnidge): This interrupt message could have been sent from
   // the service isolate directly, but would require some special case
   // code.  That would prevent this isolate getting double-interrupted
   // with OOB messages.
   Isolate* isolate = thread->isolate();
   isolate->SendInternalLibMessage(Isolate::kInterruptMsg,
                                   isolate->pause_capability());
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_tag_profile_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetTagProfile(Thread* thread, JSONStream* js) {
   JSONObject miniProfile(js);
   miniProfile.AddProperty("type", "TagProfile");
   thread->isolate()->vm_tag_counters()->PrintToJSONObject(&miniProfile);
   return true;
 }
 
 
 static const char* const tags_enum_names[] = {
-  "None",
-  "UserVM",
-  "UserOnly",
-  "VMUser",
-  "VMOnly",
-  NULL,
+    "None", "UserVM", "UserOnly", "VMUser", "VMOnly", NULL,
 };
 
 
 static const Profile::TagOrder tags_enum_values[] = {
-  Profile::kNoTags,
-  Profile::kUserVM,
-  Profile::kUser,
-  Profile::kVMUser,
-  Profile::kVM,
-  Profile::kNoTags,  // Default value.
+    Profile::kNoTags, Profile::kUserVM, Profile::kUser,
+    Profile::kVMUser, Profile::kVM,
+    Profile::kNoTags,  // Default value.
 };
 
 
 static const MethodParameter* get_cpu_profile_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new EnumParameter("tags", true, tags_enum_names),
-  new BoolParameter("_codeTransitionTags", false),
-  new Int64Parameter("timeOriginMicros", false),
-  new Int64Parameter("timeExtentMicros", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new EnumParameter("tags", true, tags_enum_names),
+    new BoolParameter("_codeTransitionTags", false),
+    new Int64Parameter("timeOriginMicros", false),
+    new Int64Parameter("timeExtentMicros", false),
+    NULL,
 };
 
 
 // TODO(johnmccutchan): Rename this to GetCpuSamples.
 static bool GetCpuProfile(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   intptr_t extra_tags = 0;
   if (BoolParameter::Parse(js->LookupParam("_codeTransitionTags"))) {
     extra_tags |= ProfilerService::kCodeTransitionTagsBit;
   }
   int64_t time_origin_micros =
       Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
   int64_t time_extent_micros =
       Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
-  ProfilerService::PrintJSON(js,
-                             tag_order,
-                             extra_tags,
-                             time_origin_micros,
+  ProfilerService::PrintJSON(js, tag_order, extra_tags, time_origin_micros,
                              time_extent_micros);
   return true;
 }
 
 
 static const MethodParameter* get_cpu_profile_timeline_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new EnumParameter("tags", true, tags_enum_names),
-  new Int64Parameter("timeOriginMicros", false),
-  new Int64Parameter("timeExtentMicros", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new EnumParameter("tags", true, tags_enum_names),
+    new Int64Parameter("timeOriginMicros", false),
+    new Int64Parameter("timeExtentMicros", false),
+    NULL,
 };
 
 
 static bool GetCpuProfileTimeline(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   int64_t time_origin_micros =
       UIntParameter::Parse(js->LookupParam("timeOriginMicros"));
   int64_t time_extent_micros =
       UIntParameter::Parse(js->LookupParam("timeExtentMicros"));
-  ProfilerService::PrintTimelineJSON(js,
-                                     tag_order,
-                                     time_origin_micros,
+  ProfilerService::PrintTimelineJSON(js, tag_order, time_origin_micros,
                                      time_extent_micros);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_samples_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new EnumParameter("tags", true, tags_enum_names),
-  new IdParameter("classId", false),
-  new Int64Parameter("timeOriginMicros", false),
-  new Int64Parameter("timeExtentMicros", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new EnumParameter("tags", true, tags_enum_names),
+    new IdParameter("classId", false),
+    new Int64Parameter("timeOriginMicros", false),
+    new Int64Parameter("timeExtentMicros", false),
+    NULL,
 };
 
 
 static bool GetAllocationSamples(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   int64_t time_origin_micros =
       Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
   int64_t time_extent_micros =
       Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
   const char* class_id = js->LookupParam("classId");
   intptr_t cid = -1;
   GetPrefixedIntegerId(class_id, "classes/", &cid);
   Isolate* isolate = thread->isolate();
   if (IsValidClassId(isolate, cid)) {
     const Class& cls = Class::Handle(GetClassForId(isolate, cid));
-    ProfilerService::PrintAllocationJSON(js,
-                                         tag_order,
-                                         cls,
-                                         time_origin_micros,
+    ProfilerService::PrintAllocationJSON(js, tag_order, cls, time_origin_micros,
                                          time_extent_micros);
   } else {
     PrintInvalidParamError(js, "classId");
   }
   return true;
 }
 
 
 static const MethodParameter* clear_cpu_profile_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool ClearCpuProfile(Thread* thread, JSONStream* js) {
   ProfilerService::ClearSamples();
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_profile_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetAllocationProfile(Thread* thread, JSONStream* js) {
   bool should_reset_accumulator = false;
   bool should_collect = false;
   if (js->HasParam("reset")) {
     if (js->ParamIs("reset", "true")) {
       should_reset_accumulator = true;
     } else {
@@ skipping 17 matching lines @@
   if (should_collect) {
     isolate->UpdateLastAllocationProfileGCTimestamp();
     isolate->heap()->CollectAllGarbage();
   }
   isolate->class_table()->AllocationProfilePrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* get_heap_map_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetHeapMap(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   isolate->heap()->PrintHeapMapToJSONStream(isolate, js);
   return true;
 }
 
 
 static const MethodParameter* request_heap_snapshot_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new BoolParameter("collectGarbage", false /* not required */),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER,
+    new BoolParameter("collectGarbage", false /* not required */), NULL,
 };
 
 
 static bool RequestHeapSnapshot(Thread* thread, JSONStream* js) {
   const bool collect_garbage =
       BoolParameter::Parse(js->LookupParam("collectGarbage"), true);
   if (Service::graph_stream.enabled()) {
     Service::SendGraphEvent(thread, collect_garbage);
   }
   // TODO(koda): Provide some id that ties this request to async response(s).
@@ skipping 32 matching lines @@
 
           event.AddProperty("chunkIndex", i);
           event.AddProperty("chunkCount", num_chunks);
           event.AddProperty("nodeCount", node_count);
         }
       }
     }
 
     uint8_t* chunk_start = buffer + (i * kChunkSize);
     intptr_t chunk_size = (i + 1 == num_chunks)
-        ? stream.bytes_written() - (i * kChunkSize)
-        : kChunkSize;
+                              ? stream.bytes_written() - (i * kChunkSize)
+                              : kChunkSize;
 
-    SendEventWithData(graph_stream.id(), "_Graph",
-                      js.buffer()->buf(), js.buffer()->length(),
-                      chunk_start, chunk_size);
+    SendEventWithData(graph_stream.id(), "_Graph", js.buffer()->buf(),
+                      js.buffer()->length(), chunk_start, chunk_size);
   }
 }
 
 
 void Service::SendInspectEvent(Isolate* isolate, const Object& inspectee) {
   if (!Service::debug_stream.enabled()) {
     return;
   }
   ServiceEvent event(isolate, ServiceEvent::kInspect);
   event.set_inspectee(&inspectee);
@@ skipping 54 matching lines @@
   extension_event.event_kind = &event_kind;
   extension_event.event_data = &event_data;
   ServiceEvent event(isolate, ServiceEvent::kExtension);
   event.set_extension_event(extension_event);
   Service::HandleEvent(&event);
 }
 
 
 class ContainsAddressVisitor : public FindObjectVisitor {
  public:
-  explicit ContainsAddressVisitor(uword addr) : addr_(addr) { }
-  virtual ~ContainsAddressVisitor() { }
+  explicit ContainsAddressVisitor(uword addr) : addr_(addr) {}
+  virtual ~ContainsAddressVisitor() {}
 
   virtual uword filter_addr() const { return addr_; }
 
   virtual bool FindObject(RawObject* obj) const {
     if (obj->IsPseudoObject()) {
       return false;
     }
     uword obj_begin = RawObject::ToAddr(obj);
     uword obj_end = obj_begin + obj->Size();
     return obj_begin <= addr_ && addr_ < obj_end;
   }
+
  private:
   uword addr_;
 };
 
 
 static const MethodParameter* get_object_by_address_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static RawObject* GetObjectHelper(Thread* thread, uword addr) {
   Object& object = Object::Handle(thread->zone());
 
   {
     NoSafepointScope no_safepoint;
     Isolate* isolate = thread->isolate();
     ContainsAddressVisitor visitor(addr);
@@ skipping 21 matching lines @@
     return true;
   }
 
   // Handle heap objects.
   uword addr = 0;
   if (!GetUnsignedIntegerId(addr_str, &addr, 16)) {
     PrintInvalidParamError(js, "address");
     return true;
   }
   bool ref = js->HasParam("ref") && js->ParamIs("ref", "true");
-  const Object& obj = Object::Handle(thread->zone(),
-      GetObjectHelper(thread, addr));
+  const Object& obj =
+      Object::Handle(thread->zone(), GetObjectHelper(thread, addr));
   if (obj.IsNull()) {
     PrintSentinel(js, kFreeSentinel);
   } else {
     obj.PrintJSON(js, ref);
   }
   return true;
 }
 
 
 static const MethodParameter* get_persistent_handles_params[] = {
-  ISOLATE_PARAMETER,
-  NULL,
+    ISOLATE_PARAMETER, NULL,
 };
 
 
-template<typename T>
+template <typename T>
 class PersistentHandleVisitor : public HandleVisitor {
  public:
   PersistentHandleVisitor(Thread* thread, JSONArray* handles)
-      : HandleVisitor(thread),
-        handles_(handles) {
+      : HandleVisitor(thread), handles_(handles) {
     ASSERT(handles_ != NULL);
   }
 
   void Append(PersistentHandle* persistent_handle) {
     JSONObject obj(handles_);
     obj.AddProperty("type", "_PersistentHandle");
     const Object& object = Object::Handle(persistent_handle->raw());
     obj.AddProperty("object", object);
   }
 
   void Append(FinalizablePersistentHandle* weak_persistent_handle) {
     if (!weak_persistent_handle->raw()->IsHeapObject()) {
       return;  // Free handle.
     }
 
     JSONObject obj(handles_);
     obj.AddProperty("type", "_WeakPersistentHandle");
-    const Object& object =
-        Object::Handle(weak_persistent_handle->raw());
+    const Object& object = Object::Handle(weak_persistent_handle->raw());
     obj.AddProperty("object", object);
+    obj.AddPropertyF("peer", "0x%" Px "", reinterpret_cast<uintptr_t>(
+                                              weak_persistent_handle->peer()));
     obj.AddPropertyF(
-        "peer",
-        "0x%" Px "",
-        reinterpret_cast<uintptr_t>(weak_persistent_handle->peer()));
-    obj.AddPropertyF(
-        "callbackAddress",
-        "0x%" Px "",
+        "callbackAddress", "0x%" Px "",
         reinterpret_cast<uintptr_t>(weak_persistent_handle->callback()));
     // Attempt to include a native symbol name.
     char* name = NativeSymbolResolver::LookupSymbolName(
-        reinterpret_cast<uintptr_t>(weak_persistent_handle->callback()),
-        NULL);
-    obj.AddProperty("callbackSymbolName",
-                    (name == NULL) ? "" : name);
+        reinterpret_cast<uintptr_t>(weak_persistent_handle->callback()), NULL);
+    obj.AddProperty("callbackSymbolName", (name == NULL) ? "" : name);
     if (name != NULL) {
       NativeSymbolResolver::FreeSymbolName(name);
     }
-    obj.AddPropertyF("externalSize",
-                     "%" Pd "",
+    obj.AddPropertyF("externalSize", "%" Pd "",
                      weak_persistent_handle->external_size());
   }
 
  protected:
   virtual void VisitHandle(uword addr) {
     T* handle = reinterpret_cast<T*>(addr);
     Append(handle);
   }
 
   JSONArray* handles_;
 };
 
 
 static bool GetPersistentHandles(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
 
   ApiState* api_state = isolate->api_state();
   ASSERT(api_state != NULL);
 
   {
     JSONObject obj(js);
     obj.AddProperty("type", "_PersistentHandles");
     // Persistent handles.
     {
       JSONArray persistent_handles(&obj, "persistentHandles");
       PersistentHandles& handles = api_state->persistent_handles();
-      PersistentHandleVisitor<PersistentHandle> visitor(
-          thread, &persistent_handles);
+      PersistentHandleVisitor<PersistentHandle> visitor(thread,
+                                                        &persistent_handles);
       handles.Visit(&visitor);
     }
     // Weak persistent handles.
     {
       JSONArray weak_persistent_handles(&obj, "weakPersistentHandles");
       FinalizablePersistentHandles& handles =
           api_state->weak_persistent_handles();
       PersistentHandleVisitor<FinalizablePersistentHandle> visitor(
           thread, &weak_persistent_handles);
       handles.VisitHandles(&visitor);
     }
   }
 
   return true;
 }
 
 
 static const MethodParameter* get_ports_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetPorts(Thread* thread, JSONStream* js) {
   MessageHandler* message_handler = thread->isolate()->message_handler();
   PortMap::PrintPortsForMessageHandler(message_handler, js);
   return true;
 }
 
 
@@ skipping 11 matching lines @@
 
 
 static bool RespondWithMalformedObject(Thread* thread, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("bart", "simpson");
   return true;
 }
 
 
 static const MethodParameter* get_object_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new UIntParameter("offset", false),
-  new UIntParameter("count", false),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new UIntParameter("offset", false),
+    new UIntParameter("count", false), NULL,
 };
 
 
 static bool GetObject(Thread* thread, JSONStream* js) {
   const char* id = js->LookupParam("objectId");
   if (id == NULL) {
     PrintMissingParamError(js, "objectId");
     return true;
   }
   if (js->HasParam("offset")) {
@@ skipping 38 matching lines @@
     PrintSentinel(js, kCollectedSentinel);
     return true;
   }
 
   PrintInvalidParamError(js, "objectId");
   return true;
 }
 
 
 static const MethodParameter* get_object_store_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetObjectStore(Thread* thread, JSONStream* js) {
   JSONObject jsobj(js);
   thread->isolate()->object_store()->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
 static const MethodParameter* get_class_list_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetClassList(Thread* thread, JSONStream* js) {
   ClassTable* table = thread->isolate()->class_table();
   JSONObject jsobj(js);
   table->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
 static const MethodParameter* get_type_arguments_list_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetTypeArgumentsList(Thread* thread, JSONStream* js) {
   bool only_with_instantiations = false;
   if (js->ParamIs("onlyWithInstantiations", "true")) {
     only_with_instantiations = true;
   }
   Zone* zone = thread->zone();
   ObjectStore* object_store = thread->isolate()->object_store();
   CanonicalTypeArgumentsSet typeargs_table(
       zone, object_store->canonical_type_arguments());
   const intptr_t table_size = typeargs_table.NumEntries();
   const intptr_t table_used = typeargs_table.NumOccupied();
-  const Array& typeargs_array = Array::Handle(
-      zone, HashTables::ToArray(typeargs_table, false));
+  const Array& typeargs_array =
+      Array::Handle(zone, HashTables::ToArray(typeargs_table, false));
   ASSERT(typeargs_array.Length() == table_used);
   TypeArguments& typeargs = TypeArguments::Handle(zone);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "TypeArgumentsList");
   jsobj.AddProperty("canonicalTypeArgumentsTableSize", table_size);
   jsobj.AddProperty("canonicalTypeArgumentsTableUsed", table_used);
   JSONArray members(&jsobj, "typeArguments");
   for (intptr_t i = 0; i < table_used; i++) {
     typeargs ^= typeargs_array.At(i);
     if (!typeargs.IsNull()) {
       if (!only_with_instantiations || typeargs.HasInstantiations()) {
         members.AddValue(typeargs);
       }
     }
   }
   typeargs_table.Release();
   return true;
 }
 
 
 static const MethodParameter* get_version_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetVersion(Thread* thread, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Version");
   jsobj.AddProperty("major",
                     static_cast<intptr_t>(SERVICE_PROTOCOL_MAJOR_VERSION));
   jsobj.AddProperty("minor",
                     static_cast<intptr_t>(SERVICE_PROTOCOL_MINOR_VERSION));
   jsobj.AddProperty("_privateMajor", static_cast<intptr_t>(0));
   jsobj.AddProperty("_privateMinor", static_cast<intptr_t>(0));
   return true;
 }
 
 
 class ServiceIsolateVisitor : public IsolateVisitor {
  public:
-  explicit ServiceIsolateVisitor(JSONArray* jsarr)
-      : jsarr_(jsarr) {
-  }
+  explicit ServiceIsolateVisitor(JSONArray* jsarr) : jsarr_(jsarr) {}
 
   virtual ~ServiceIsolateVisitor() {}
 
   void VisitIsolate(Isolate* isolate) {
     if ((isolate != Dart::vm_isolate()) &&
         !ServiceIsolate::IsServiceIsolateDescendant(isolate)) {
       jsarr_->AddValue(isolate);
     }
   }
 
  private:
   JSONArray* jsarr_;
 };
 
 
 static const MethodParameter* get_vm_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 void Service::PrintJSONForVM(JSONStream* js, bool ref) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", (ref ? "@VM" : "VM"));
   jsobj.AddProperty("name", GetVMName());
   if (ref) {
     return;
   }
   Isolate* vm_isolate = Dart::vm_isolate();
   jsobj.AddProperty("architectureBits", static_cast<intptr_t>(kBitsPerWord));
   jsobj.AddProperty("targetCPU", CPU::Id());
   jsobj.AddProperty("hostCPU", HostCPUFeatures::hardware());
   jsobj.AddProperty("version", Version::String());
   jsobj.AddProperty("_profilerMode", FLAG_profile_vm ? "VM" : "Dart");
   jsobj.AddProperty64("pid", OS::ProcessId());
   jsobj.AddProperty64("_maxRSS", OS::MaxRSS());
-  int64_t start_time_millis = (vm_isolate->start_time() /
-                               kMicrosecondsPerMillisecond);
+  int64_t start_time_millis =
+      (vm_isolate->start_time() / kMicrosecondsPerMillisecond);
   jsobj.AddPropertyTimeMillis("startTime", start_time_millis);
   // Construct the isolate list.
   {
     JSONArray jsarr(&jsobj, "isolates");
     ServiceIsolateVisitor visitor(&jsarr);
     Isolate::VisitIsolates(&visitor);
   }
 }
 
 
 static bool GetVM(Thread* thread, JSONStream* js) {
   Service::PrintJSONForVM(js, false);
   return true;
 }
 
 
 static const MethodParameter* restart_vm_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool RestartVM(Thread* thread, JSONStream* js) {
   Isolate::KillAllIsolates(Isolate::kVMRestartMsg);
   PrintSuccess(js);
   return true;
 }
 
 
 static const char* exception_pause_mode_names[] = {
-  "All",
-  "None",
-  "Unhandled",
-  NULL,
+    "All", "None", "Unhandled", NULL,
 };
 
 
 static Dart_ExceptionPauseInfo exception_pause_mode_values[] = {
-  kPauseOnAllExceptions,
-  kNoPauseOnExceptions,
-  kPauseOnUnhandledExceptions,
-  kInvalidExceptionPauseInfo,
+    kPauseOnAllExceptions, kNoPauseOnExceptions, kPauseOnUnhandledExceptions,
+    kInvalidExceptionPauseInfo,
 };
 
 
 static const MethodParameter* set_exception_pause_mode_params[] = {
-  ISOLATE_PARAMETER,
-  new EnumParameter("mode", true, exception_pause_mode_names),
-  NULL,
+    ISOLATE_PARAMETER,
+    new EnumParameter("mode", true, exception_pause_mode_names), NULL,
 };
 
 
 static bool SetExceptionPauseMode(Thread* thread, JSONStream* js) {
   const char* mode = js->LookupParam("mode");
   if (mode == NULL) {
     PrintMissingParamError(js, "mode");
     return true;
   }
   Dart_ExceptionPauseInfo info =
       EnumMapper(mode, exception_pause_mode_names, exception_pause_mode_values);
   if (info == kInvalidExceptionPauseInfo) {
     PrintInvalidParamError(js, "mode");
     return true;
   }
   Isolate* isolate = thread->isolate();
   isolate->debugger()->SetExceptionPauseInfo(info);
   if (Service::debug_stream.enabled()) {
     ServiceEvent event(isolate, ServiceEvent::kDebuggerSettingsUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_flag_list_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool GetFlagList(Thread* thread, JSONStream* js) {
   Flags::PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* set_flags_params[] = {
-  NO_ISOLATE_PARAMETER,
-  NULL,
+    NO_ISOLATE_PARAMETER, NULL,
 };
 
 
 static bool SetFlag(Thread* thread, JSONStream* js) {
   const char* flag_name = js->LookupParam("name");
   if (flag_name == NULL) {
     PrintMissingParamError(js, "name");
     return true;
   }
   const char* flag_value = js->LookupParam("value");
   if (flag_value == NULL) {
     PrintMissingParamError(js, "value");
     return true;
   }
   const char* error = NULL;
   if (Flags::SetFlag(flag_name, flag_value, &error)) {
     PrintSuccess(js);
     return true;
   } else {
     JSONObject jsobj(js);
     jsobj.AddProperty("type", "Error");
     jsobj.AddProperty("message", error);
     return true;
   }
 }
 
 
 static const MethodParameter* set_library_debuggable_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("libraryId", true),
-  new BoolParameter("isDebuggable", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new IdParameter("libraryId", true),
+    new BoolParameter("isDebuggable", true), NULL,
 };
 
 
 static bool SetLibraryDebuggable(Thread* thread, JSONStream* js) {
   const char* lib_id = js->LookupParam("libraryId");
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(LookupHeapObject(thread, lib_id,
-                                                &lookup_result));
+  Object& obj =
+      Object::Handle(LookupHeapObject(thread, lib_id, &lookup_result));
   const bool is_debuggable =
       BoolParameter::Parse(js->LookupParam("isDebuggable"), false);
   if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
     if (lib.is_dart_scheme()) {
       const String& url = String::Handle(lib.url());
       if (url.StartsWith(Symbols::DartSchemePrivate())) {
         PrintIllegalParamError(js, "libraryId");
         return true;
       }
     }
     lib.set_debuggable(is_debuggable);
     PrintSuccess(js);
     return true;
   }
   PrintInvalidParamError(js, "libraryId");
   return true;
 }
 
 
 static const MethodParameter* set_name_params[] = {
-  ISOLATE_PARAMETER,
-  new MethodParameter("name", true),
-  NULL,
+    ISOLATE_PARAMETER, new MethodParameter("name", true), NULL,
 };
 
 
 static bool SetName(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   isolate->set_debugger_name(js->LookupParam("name"));
   if (Service::isolate_stream.enabled()) {
     ServiceEvent event(isolate, ServiceEvent::kIsolateUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* set_vm_name_params[] = {
-  NO_ISOLATE_PARAMETER,
-  new MethodParameter("name", true),
-  NULL,
+    NO_ISOLATE_PARAMETER, new MethodParameter("name", true), NULL,
 };
 
 
 static bool SetVMName(Thread* thread, JSONStream* js) {
   const char* name_param = js->LookupParam("name");
   free(vm_name);
   vm_name = strdup(name_param);
   if (Service::vm_stream.enabled()) {
     ServiceEvent event(NULL, ServiceEvent::kVMUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* set_trace_class_allocation_params[] = {
-  RUNNABLE_ISOLATE_PARAMETER,
-  new IdParameter("classId", true),
-  new BoolParameter("enable", true),
-  NULL,
+    RUNNABLE_ISOLATE_PARAMETER, new IdParameter("classId", true),
+    new BoolParameter("enable", true), NULL,
 };
 
 
 static bool SetTraceClassAllocation(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
-    js->PrintError(kFeatureDisabled,
+    js->PrintError(
+        kFeatureDisabled,
         "Cannot trace allocation when running a precompiled program.");
     return true;
   }
   const char* class_id = js->LookupParam("classId");
   const bool enable = BoolParameter::Parse(js->LookupParam("enable"));
   intptr_t cid = -1;
   GetPrefixedIntegerId(class_id, "classes/", &cid);
   Isolate* isolate = thread->isolate();
   if (!IsValidClassId(isolate, cid)) {
     PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Handle(GetClassForId(isolate, cid));
   ASSERT(!cls.IsNull());
   cls.SetTraceAllocation(enable);
   PrintSuccess(js);
   return true;
 }
 
 
+// clang-format off
 static const ServiceMethodDescriptor service_methods_[] = {
   { "_dumpIdZone", DumpIdZone, NULL },
   { "_echo", Echo,
     NULL },
   { "_respondWithMalformedJson", RespondWithMalformedJson,
     NULL },
   { "_respondWithMalformedObject", RespondWithMalformedObject,
     NULL },
   { "_triggerEchoEvent", TriggerEchoEvent,
     NULL },
@@ skipping 95 matching lines @@
     set_library_debuggable_params },
   { "setName", SetName,
     set_name_params },
   { "_setTraceClassAllocation", SetTraceClassAllocation,
     set_trace_class_allocation_params },
   { "setVMName", SetVMName,
     set_vm_name_params },
   { "_setVMTimelineFlags", SetVMTimelineFlags,
     set_vm_timeline_flags_params },
 };
-
+// clang-format on
 
 const ServiceMethodDescriptor* FindMethod(const char* method_name) {
-  intptr_t num_methods = sizeof(service_methods_) /
-                         sizeof(service_methods_[0]);
+  intptr_t num_methods = sizeof(service_methods_) / sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
     const ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart