clang-format runtime/vm

runtime/vm/service_isolate.cc

 // Copyright (c) 2015, 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_isolate.h"
 
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/service.h"
 #include "vm/symbols.h"
 #include "vm/thread_pool.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 #define Z (T->zone())
 
 
 DEFINE_FLAG(bool, trace_service, false, "Trace VM service requests.");
-DEFINE_FLAG(bool, trace_service_pause_events, false,
+DEFINE_FLAG(bool,
+            trace_service_pause_events,
+            false,
             "Trace VM service isolate pause events.");
-DEFINE_FLAG(bool, trace_service_verbose, false,
+DEFINE_FLAG(bool,
+            trace_service_verbose,
+            false,
             "Provide extra service tracing information.");
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 // These must be kept in sync with service/constants.dart
 #define VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID 0
 #define VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID 1
 #define VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID 2
 
 #define VM_SERVICE_WEB_SERVER_CONTROL_MESSAGE_ID 3
 #define VM_SERVICE_SERVER_INFO_MESSAGE_ID 4
 
-static RawArray* MakeServiceControlMessage(Dart_Port port_id, intptr_t code,
+static RawArray* MakeServiceControlMessage(Dart_Port port_id,
+                                           intptr_t code,
                                            const String& name) {
   const Array& list = Array::Handle(Array::New(4));
   ASSERT(!list.IsNull());
   const Integer& code_int = Integer::Handle(Integer::New(code));
   const Integer& port_int = Integer::Handle(Integer::New(port_id));
   const SendPort& send_port = SendPort::Handle(SendPort::New(port_id));
   list.SetAt(0, code_int);
   list.SetAt(1, port_int);
   list.SetAt(2, send_port);
   list.SetAt(3, name);
@@ skipping 30 matching lines @@
 Dart_Port ServiceIsolate::origin_ = ILLEGAL_PORT;
 Dart_IsolateCreateCallback ServiceIsolate::create_callback_ = NULL;
 uint8_t* ServiceIsolate::exit_message_ = NULL;
 intptr_t ServiceIsolate::exit_message_length_ = 0;
 Monitor* ServiceIsolate::monitor_ = NULL;
 bool ServiceIsolate::initializing_ = true;
 bool ServiceIsolate::shutting_down_ = false;
 char* ServiceIsolate::server_address_ = NULL;
 
 void ServiceIsolate::RequestServerInfo(const SendPort& sp) {
-  const Array& message =
-      Array::Handle(
-          MakeServerControlMessage(sp,
-                                   VM_SERVICE_SERVER_INFO_MESSAGE_ID,
-                                   false /* ignored */));
+  const Array& message = Array::Handle(MakeServerControlMessage(
+      sp, VM_SERVICE_SERVER_INFO_MESSAGE_ID, false /* ignored */));
   ASSERT(!message.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(message);
   intptr_t len = writer.BytesWritten();
   PortMap::PostMessage(new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 void ServiceIsolate::ControlWebServer(const SendPort& sp, bool enable) {
-  const Array& message =
-      Array::Handle(
-          MakeServerControlMessage(sp,
-                                   VM_SERVICE_WEB_SERVER_CONTROL_MESSAGE_ID,
-                                   enable));
+  const Array& message = Array::Handle(MakeServerControlMessage(
+      sp, VM_SERVICE_WEB_SERVER_CONTROL_MESSAGE_ID, enable));
   ASSERT(!message.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(message);
   intptr_t len = writer.BytesWritten();
   PortMap::PostMessage(new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 void ServiceIsolate::SetServerAddress(const char* address) {
@@ skipping 67 matching lines @@
   }
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   if (IsServiceIsolateDescendant(isolate)) {
     return false;
   }
   ASSERT(isolate != NULL);
   HANDLESCOPE(thread);
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
-  const Array& list = Array::Handle(
-      MakeServiceControlMessage(Dart_GetMainPortId(),
-                                VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID,
-                                name));
+  const Array& list = Array::Handle(MakeServiceControlMessage(
+      Dart_GetMainPortId(), VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID, name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
     OS::Print("vm-service: Isolate %s %" Pd64 " registered.\n",
-              name.ToCString(),
-              Dart_GetMainPortId());
+              name.ToCString(), Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 bool ServiceIsolate::SendIsolateShutdownMessage() {
   if (!IsRunning()) {
     return false;
   }
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   if (IsServiceIsolateDescendant(isolate)) {
     return false;
   }
   ASSERT(isolate != NULL);
   HANDLESCOPE(thread);
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
-  const Array& list = Array::Handle(
-      MakeServiceControlMessage(Dart_GetMainPortId(),
-                                VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID,
-                                name));
+  const Array& list = Array::Handle(MakeServiceControlMessage(
+      Dart_GetMainPortId(), VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID, name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
     OS::Print("vm-service: Isolate %s %" Pd64 " deregistered.\n",
-              name.ToCString(),
-              Dart_GetMainPortId());
+              name.ToCString(), Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 void ServiceIsolate::SendServiceExitMessage() {
   if (!IsRunning()) {
     return;
   }
   if ((exit_message_ == NULL) || (exit_message_length_ == 0)) {
     return;
   }
   if (FLAG_trace_service) {
     OS::Print("vm-service: sending service exit message.\n");
   }
-  PortMap::PostMessage(new Message(port_,
-                                   exit_message_,
-                                   exit_message_length_,
+  PortMap::PostMessage(new Message(port_, exit_message_, exit_message_length_,
                                    Message::kNormalPriority));
 }
 
 
 void ServiceIsolate::SetServicePort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   port_ = port;
 }
 
 
@@ skipping 61 matching lines @@
   initializing_ = false;
   ml.NotifyAll();
 }
 
 
 class RunServiceTask : public ThreadPool::Task {
  public:
   virtual void Run() {
     ASSERT(Isolate::Current() == NULL);
 #ifndef PRODUCT
-    TimelineDurationScope tds(Timeline::GetVMStream(),
-                              "ServiceIsolateStartup");
+    TimelineDurationScope tds(Timeline::GetVMStream(), "ServiceIsolateStartup");
 #endif  // !PRODUCT
     char* error = NULL;
     Isolate* isolate = NULL;
 
     Dart_IsolateCreateCallback create_callback =
         ServiceIsolate::create_callback();
     // TODO(johnmccutchan): Support starting up service isolate without embedder
     // provided isolate creation callback.
     if (create_callback == NULL) {
       ServiceIsolate::FinishedInitializing();
       return;
     }
 
     Dart_IsolateFlags api_flags;
     Isolate::FlagsInitialize(&api_flags);
 
-    isolate =
-        reinterpret_cast<Isolate*>(create_callback(ServiceIsolate::kName,
-                                                   NULL,
-                                                   NULL,
-                                                   NULL,
-                                                   &api_flags,
-                                                   NULL,
-                                                   &error));
+    isolate = reinterpret_cast<Isolate*>(create_callback(
+        ServiceIsolate::kName, NULL, NULL, NULL, &api_flags, NULL, &error));
     if (isolate == NULL) {
       if (FLAG_trace_service) {
         OS::PrintErr("vm-service: Isolate creation error: %s\n", error);
       }
       ServiceIsolate::SetServiceIsolate(NULL);
       ServiceIsolate::FinishedInitializing();
       ServiceIsolate::FinishedExiting();
       return;
     }
 
     bool got_unwind;
     {
       ASSERT(Isolate::Current() == NULL);
       StartIsolateScope start_scope(isolate);
       ServiceIsolate::ConstructExitMessageAndCache(isolate);
       got_unwind = RunMain(isolate);
     }
 
     if (got_unwind) {
       ShutdownIsolate(reinterpret_cast<uword>(isolate));
       return;
     }
 
     ServiceIsolate::FinishedInitializing();
 
-    isolate->message_handler()->Run(Dart::thread_pool(),
-                                    NULL,
-                                    ShutdownIsolate,
+    isolate->message_handler()->Run(Dart::thread_pool(), NULL, ShutdownIsolate,
                                     reinterpret_cast<uword>(isolate));
   }
 
  protected:
   static void ShutdownIsolate(uword parameter) {
     if (FLAG_trace_service) {
       OS::Print("vm-service: ShutdownIsolate\n");
     }
     Isolate* I = reinterpret_cast<Isolate*>(parameter);
     ASSERT(ServiceIsolate::IsServiceIsolate(I));
@@ skipping 27 matching lines @@
     }
     ServiceIsolate::FinishedExiting();
   }
 
   bool RunMain(Isolate* I) {
     Thread* T = Thread::Current();
     ASSERT(I == T->isolate());
     StackZone zone(T);
     HANDLESCOPE(T);
     // Invoke main which will return the loadScriptPort.
-    const Library& root_library = Library::Handle(Z,
-        I->object_store()->root_library());
+    const Library& root_library =
+        Library::Handle(Z, I->object_store()->root_library());
     if (root_library.IsNull()) {
       if (FLAG_trace_service) {
         OS::Print("vm-service: Embedder did not install a script.");
       }
       // Service isolate is not supported by embedder.
       return false;
     }
     ASSERT(!root_library.IsNull());
     const String& entry_name = String::Handle(Z, String::New("main"));
     ASSERT(!entry_name.IsNull());
-    const Function& entry = Function::Handle(Z,
-        root_library.LookupFunctionAllowPrivate(entry_name));
+    const Function& entry = Function::Handle(
+        Z, root_library.LookupFunctionAllowPrivate(entry_name));
     if (entry.IsNull()) {
       // Service isolate is not supported by embedder.
       if (FLAG_trace_service) {
         OS::Print("vm-service: Embedder did not provide a main function.");
       }
       return false;
     }
     ASSERT(!entry.IsNull());
-    const Object& result = Object::Handle(Z,
-        DartEntry::InvokeFunction(entry, Object::empty_array()));
+    const Object& result = Object::Handle(
+        Z, DartEntry::InvokeFunction(entry, Object::empty_array()));
     ASSERT(!result.IsNull());
     if (result.IsError()) {
       // Service isolate did not initialize properly.
       if (FLAG_trace_service) {
         const Error& error = Error::Cast(result);
         OS::Print("vm-service: Calling main resulted in an error: %s",
                   error.ToErrorCString());
       }
       if (result.IsUnwindError()) {
         return true;
@@ skipping 62 matching lines @@
   }
 }
 
 
 void ServiceIsolate::BootVmServiceLibrary() {
   Thread* thread = Thread::Current();
   const Library& vmservice_library =
       Library::Handle(Library::LookupLibrary(thread, Symbols::DartVMService()));
   ASSERT(!vmservice_library.IsNull());
   const String& boot_function_name = String::Handle(String::New("boot"));
-  const Function& boot_function =
-      Function::Handle(
-          vmservice_library.LookupFunctionAllowPrivate(boot_function_name));
+  const Function& boot_function = Function::Handle(
+      vmservice_library.LookupFunctionAllowPrivate(boot_function_name));
   ASSERT(!boot_function.IsNull());
-  const Object& result =
-      Object::Handle(
-          DartEntry::InvokeFunction(boot_function, Object::empty_array()));
+  const Object& result = Object::Handle(
+      DartEntry::InvokeFunction(boot_function, Object::empty_array()));
   ASSERT(!result.IsNull());
   Dart_Port port = ILLEGAL_PORT;
   if (result.IsReceivePort()) {
     port = ReceivePort::Cast(result).Id();
   }
   ASSERT(port != ILLEGAL_PORT);
   ServiceIsolate::SetServicePort(port);
 }
 
 
-void ServiceIsolate::VisitObjectPointers(ObjectPointerVisitor* visitor) {
-}
+void ServiceIsolate::VisitObjectPointers(ObjectPointerVisitor* visitor) {}
 
 }  // namespace dart