clang-format runtime/lib

runtime/lib/isolate.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/message_handler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/service.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, i_like_slow_isolate_spawn, false,
+DEFINE_FLAG(bool,
+            i_like_slow_isolate_spawn,
+            false,
             "Block the parent thread when loading spawned isolates.");
 
 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);
 }
 
 
 DEFINE_NATIVE_ENTRY(CapabilityImpl_factory, 1) {
   ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
@@ skipping 14 matching lines @@
   int64_t id = cap.Id();
   int32_t hi = static_cast<int32_t>(id >> 32);
   int32_t lo = static_cast<int32_t>(id);
   int32_t hash = (hi ^ lo) & kSmiMax;
   return Smi::New(hash);
 }
 
 
 DEFINE_NATIVE_ENTRY(RawReceivePortImpl_factory, 1) {
   ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
-  Dart_Port port_id =
-      PortMap::CreatePort(isolate->message_handler());
+  Dart_Port port_id = PortMap::CreatePort(isolate->message_handler());
   return ReceivePort::New(port_id, false /* not control port */);
 }
 
 
 DEFINE_NATIVE_ENTRY(RawReceivePortImpl_get_id, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
   return Integer::NewFromUint64(port.Id());
 }
 
 
@@ skipping 29 matching lines @@
 
 DEFINE_NATIVE_ENTRY(SendPortImpl_sendInternal_, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   // TODO(iposva): Allow for arbitrary messages to be sent.
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, obj, arguments->NativeArgAt(1));
 
   const Dart_Port destination_port_id = port.Id();
   const bool can_send_any_object = isolate->origin_id() == port.origin_id();
 
   if (ApiObjectConverter::CanConvert(obj.raw())) {
-    PortMap::PostMessage(new Message(
-        destination_port_id, obj.raw(), Message::kNormalPriority));
+    PortMap::PostMessage(
+        new Message(destination_port_id, obj.raw(), Message::kNormalPriority));
   } else {
     uint8_t* data = NULL;
     MessageWriter writer(&data, &allocator, can_send_any_object);
     writer.WriteMessage(obj);
 
     // TODO(turnidge): Throw an exception when the return value is false?
-    PortMap::PostMessage(new Message(destination_port_id,
-                                     data, writer.BytesWritten(),
+    PortMap::PostMessage(new Message(destination_port_id, data,
+                                     writer.BytesWritten(),
                                      Message::kNormalPriority));
   }
   return Object::null();
 }
 
 
 static void ThrowIsolateSpawnException(const String& message) {
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, message);
   Exceptions::ThrowByType(Exceptions::kIsolateSpawn, args);
@@ skipping 13 matching lines @@
       ReportError(
           "Isolate spawn is not supported by this Dart implementation\n");
       delete state_;
       state_ = NULL;
       return;
     }
 
     // Make a copy of the state's isolate flags and hand it to the callback.
     Dart_IsolateFlags api_flags = *(state_->isolate_flags());
 
-    Isolate* isolate = reinterpret_cast<Isolate*>(
-        (callback)(state_->script_url(),
-                   state_->function_name(),
-                   state_->package_root(),
-                   state_->package_config(),
-                   &api_flags,
-                   state_->init_data(),
-                   &error));
+    Isolate* isolate = reinterpret_cast<Isolate*>((callback)(
+        state_->script_url(), state_->function_name(), state_->package_root(),
+        state_->package_config(), &api_flags, state_->init_data(), &error));
     state_->DecrementSpawnCount();
     if (isolate == NULL) {
       ReportError(error);
       delete state_;
       state_ = NULL;
       free(error);
       return;
     }
 
     if (state_->origin_id() != ILLEGAL_PORT) {
@@ skipping 63 matching lines @@
 
       const char* utf8_package_root =
           packageRoot.IsNull() ? NULL : String2UTF8(packageRoot);
       const char* utf8_package_config =
           packageConfig.IsNull() ? NULL : String2UTF8(packageConfig);
 
       bool fatal_errors = fatalErrors.IsNull() ? true : fatalErrors.value();
       Dart_Port on_exit_port = onExit.IsNull() ? ILLEGAL_PORT : onExit.Id();
       Dart_Port on_error_port = onError.IsNull() ? ILLEGAL_PORT : onError.Id();
 
-      IsolateSpawnState* state =
-          new IsolateSpawnState(port.Id(),
-                                isolate->origin_id(),
-                                isolate->init_callback_data(),
-                                String2UTF8(script_uri),
-                                func,
-                                message,
-                                isolate->spawn_count_monitor(),
-                                isolate->spawn_count(),
-                                utf8_package_root,
-                                utf8_package_config,
-                                paused.value(),
-                                fatal_errors,
-                                on_exit_port,
-                                on_error_port);
+      IsolateSpawnState* state = new IsolateSpawnState(
+          port.Id(), isolate->origin_id(), isolate->init_callback_data(),
+          String2UTF8(script_uri), func, message,
+          isolate->spawn_count_monitor(), isolate->spawn_count(),
+          utf8_package_root, utf8_package_config, paused.value(), fatal_errors,
+          on_exit_port, on_error_port);
       ThreadPool::Task* spawn_task = new SpawnIsolateTask(state);
 
       isolate->IncrementSpawnCount();
       if (FLAG_i_like_slow_isolate_spawn) {
         // We block the parent isolate while the child isolate loads.
         Isolate* saved = Isolate::Current();
         Thread::ExitIsolate();
         spawn_task->Run();
         delete spawn_task;
         spawn_task = NULL;
@@ skipping 20 matching lines @@
                                    const Library& library,
                                    const String& uri,
                                    char** error) {
   const char* result = NULL;
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   Dart_LibraryTagHandler handler = isolate->library_tag_handler();
   if (handler != NULL) {
     TransitionVMToNative transition(thread);
     Dart_EnterScope();
-    Dart_Handle handle = handler(Dart_kCanonicalizeUrl,
-                                 Api::NewHandle(thread, library.raw()),
-                                 Api::NewHandle(thread, uri.raw()));
+    Dart_Handle handle =
+        handler(Dart_kCanonicalizeUrl, Api::NewHandle(thread, library.raw()),
+                Api::NewHandle(thread, uri.raw()));
     const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
     if (obj.IsString()) {
       result = String2UTF8(String::Cast(obj));
     } else if (obj.IsError()) {
       Error& error_obj = Error::Handle();
       error_obj ^= obj.raw();
       *error = zone->PrintToString("Unable to canonicalize uri '%s': %s",
                                    uri.ToCString(), error_obj.ToErrorCString());
     } else {
-      *error = zone->PrintToString("Unable to canonicalize uri '%s': "
-                                   "library tag handler returned wrong type",
-                                   uri.ToCString());
+      *error = zone->PrintToString(
+          "Unable to canonicalize uri '%s': "
+          "library tag handler returned wrong type",
+          uri.ToCString());
     }
     Dart_ExitScope();
   } else {
     *error = zone->PrintToString(
         "Unable to canonicalize uri '%s': no library tag handler found.",
         uri.ToCString());
   }
   return result;
 }
 
@@ skipping 13 matching lines @@
   GET_NATIVE_ARGUMENT(Bool, checked, arguments->NativeArgAt(8));
 
   GET_NATIVE_ARGUMENT(Array, environment, arguments->NativeArgAt(9));
 
   GET_NATIVE_ARGUMENT(String, packageRoot, arguments->NativeArgAt(10));
   GET_NATIVE_ARGUMENT(String, packageConfig, arguments->NativeArgAt(11));
 
   if (Snapshot::IncludesCode(Dart::snapshot_kind())) {
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, String::Handle(String::New(
-        "Isolate.spawnUri not supported under precompilation")));
+                      "Isolate.spawnUri not supported under precompilation")));
     Exceptions::ThrowByType(Exceptions::kUnsupported, args);
     UNREACHABLE();
   }
 
   // Canonicalize the uri with respect to the current isolate.
   const Library& root_lib =
       Library::Handle(isolate->object_store()->root_library());
   char* error = NULL;
   const char* canonical_uri = CanonicalizeUri(thread, root_lib, uri, &error);
   if (canonical_uri == NULL) {
     const String& msg = String::Handle(String::New(error));
     ThrowIsolateSpawnException(msg);
   }
 
   const char* utf8_package_root =
       packageRoot.IsNull() ? NULL : String2UTF8(packageRoot);
   const char* utf8_package_config =
       packageConfig.IsNull() ? NULL : String2UTF8(packageConfig);
 
   bool fatal_errors = fatalErrors.IsNull() ? true : fatalErrors.value();
   Dart_Port on_exit_port = onExit.IsNull() ? ILLEGAL_PORT : onExit.Id();
   Dart_Port on_error_port = onError.IsNull() ? ILLEGAL_PORT : onError.Id();
 
-  IsolateSpawnState* state =
-      new IsolateSpawnState(
-          port.Id(),
-          isolate->init_callback_data(),
-          canonical_uri,
-          utf8_package_root,
-          utf8_package_config,
-          args,
-          message,
-          isolate->spawn_count_monitor(),
-          isolate->spawn_count(),
-          paused.value(),
-          fatal_errors,
-          on_exit_port,
-          on_error_port);
+  IsolateSpawnState* state = new IsolateSpawnState(
+      port.Id(), isolate->init_callback_data(), canonical_uri,
+      utf8_package_root, utf8_package_config, args, message,
+      isolate->spawn_count_monitor(), isolate->spawn_count(), paused.value(),
+      fatal_errors, on_exit_port, on_error_port);
 
   // If we were passed a value then override the default flags state for
   // checked mode.
   if (!checked.IsNull()) {
     bool val = checked.value();
     Dart_IsolateFlags* flags = state->isolate_flags();
     flags->enable_asserts = val;
     flags->enable_type_checks = val;
   }
 
@@ skipping 16 matching lines @@
     delete spawn_task;
     spawn_task = NULL;
   }
   return Object::null();
 }
 
 
 DEFINE_NATIVE_ENTRY(Isolate_getPortAndCapabilitiesOfCurrentIsolate, 0) {
   const Array& result = Array::Handle(Array::New(3));
   result.SetAt(0, SendPort::Handle(SendPort::New(isolate->main_port())));
-  result.SetAt(1, Capability::Handle(
-                      Capability::New(isolate->pause_capability())));
-  result.SetAt(2, Capability::Handle(
-                      Capability::New(isolate->terminate_capability())));
+  result.SetAt(
+      1, Capability::Handle(Capability::New(isolate->pause_capability())));
+  result.SetAt(
+      2, Capability::Handle(Capability::New(isolate->terminate_capability())));
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(Isolate_getCurrentRootUriStr, 0) {
-  const Library& root_lib = Library::Handle(zone,
-      isolate->object_store()->root_library());
+  const Library& root_lib =
+      Library::Handle(zone, isolate->object_store()->root_library());
   return root_lib.url();
 }
 
 
 DEFINE_NATIVE_ENTRY(Isolate_sendOOB, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, msg, arguments->NativeArgAt(1));
 
   // Make sure to route this request to the isolate library OOB mesage handler.
   msg.SetAt(0, Smi::Handle(Smi::New(Message::kIsolateLibOOBMsg)));
 
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(msg);
 
-  PortMap::PostMessage(new Message(port.Id(),
-                                   data, writer.BytesWritten(),
+  PortMap::PostMessage(new Message(port.Id(), data, writer.BytesWritten(),
                                    Message::kOOBPriority));
   return Object::null();
 }
 
 }  // namespace dart