Rework service extensions to be safe

runtime/vm/isolate.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 474 matching lines @@
   } else {
     const Object& result = Object::Handle(zone,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
       success = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
+  if (success) {
+    const Object& result =
+        Object::Handle(zone, I->InvokePendingExtensionCalls());
+    if (result.IsError()) {
+      success = ProcessUnhandledException(Error::Cast(result));

[Ivan Posva, 2015/08/20 20:46:05]

We should propagate errors to the service isolate here instead of the isolate
itself. Unless we have an UnwindError of course.

[Cutch, 2015/08/21 14:18:56]

Done.

+    } else {
+      ASSERT(result.IsNull());
+    }
+  }
   return success;
 }
 
 
 void IsolateMessageHandler::NotifyPauseOnStart() {
   if (Service::debug_stream.enabled()) {
     StartIsolateScope start_isolate(isolate());
     StackZone zone(I);
     HandleScope handle_scope(I);
     ServiceEvent pause_event(isolate(), ServiceEvent::kPauseStart);
@@ skipping 184 matching lines @@
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       object_id_ring_(NULL),
       trace_buffer_(NULL),
       profiler_data_(NULL),
       tag_table_(GrowableObjectArray::null()),
       current_tag_(UserTag::null()),
       default_tag_(UserTag::null()),
       collected_closures_(GrowableObjectArray::null()),
       deoptimized_code_array_(GrowableObjectArray::null()),
+      pending_extension_calls_(GrowableObjectArray::null()),
       metrics_list_head_(NULL),
       compilation_allowed_(true),
       cha_(NULL),
       next_(NULL),
       pause_loop_monitor_(NULL),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_INIT)
       reusable_handles_() {
   flags_.CopyFrom(api_flags);
   set_vm_tag(VMTag::kEmbedderTagId);
@@ skipping 904 matching lines @@
   // Visit the tag table which is stored in the isolate.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&tag_table_));
 
   // Visit array of closures pending precompilation.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&collected_closures_));
 
   // Visit the deoptimized code array which is stored in the isolate.
   visitor->VisitPointer(
       reinterpret_cast<RawObject**>(&deoptimized_code_array_));
 
+  // Visit the pending service extension calls.
+  visitor->VisitPointer(
+      reinterpret_cast<RawObject**>(&pending_extension_calls_));
+
   // Visit objects in the debugger.
   debugger()->VisitObjectPointers(visitor);
 
   // Visit objects that are being used for deoptimization.
   if (deopt_context() != NULL) {
     deopt_context()->VisitObjectPointers(visitor);
   }
 
   // Visit objects in thread registry (e.g., Dart stack, handles in zones).
   thread_registry()->VisitObjectPointers(visitor, validate_frames);
@@ skipping 185 matching lines @@
   if (deoptimized_code.IsNull()) {
     // Not tracking deoptimized code.
     return;
   }
   // TODO(johnmccutchan): Scan this array and the isolate's profile before
   // old space GC and remove the keep_code flag.
   deoptimized_code.Add(code);
 }
 
 
+void Isolate::set_pending_extension_calls(const GrowableObjectArray& value) {
+  pending_extension_calls_ = value.raw();
+}
+
+
+RawObject* Isolate::InvokePendingExtensionCalls() {
+  GrowableObjectArray& calls =
+      GrowableObjectArray::Handle(GetAndClearPendingExtensionCalls());
+  if (calls.IsNull()) {
+    return Object::null();
+  }
+  const Array& arguments = Array::Handle(Array::New(1, Heap::kNew));
+  Object& result = Object::Handle();
+  Instance& closure = Instance::Handle();
+  for (intptr_t i = 0; i < calls.Length(); i++) {
+    closure ^= calls.At(i);
+    ASSERT(!closure.IsNull());
+    arguments.SetAt(0, closure);
+    result = DartEntry::InvokeClosure(arguments);
+    if (result.IsError()) {
+      return result.raw();

[Ivan Posva, 2015/08/20 20:46:05]

Maybe we want to requeue the non-handled extension calls in case errors are not
fatal? Actually, errors in extension calls should never be fatal as they come in
from a side-channel.

As discussed we should send these errors back to the VM service.

[Cutch, 2015/08/21 14:18:56]

Done.

+    }
+    result = DartLibraryCalls::DrainMicrotaskQueue();
+    if (result.IsError()) {
+      return result.raw();
+    }
+  }
+  return Object::null();
+}
+
+
+RawGrowableObjectArray* Isolate::GetAndClearPendingExtensionCalls() {
+  RawGrowableObjectArray* r = pending_extension_calls_;
+  pending_extension_calls_ = GrowableObjectArray::null();
+  return r;
+}
+
+
+void Isolate::AppendExtensionCall(const Instance& closure) {
+  GrowableObjectArray& calls =
+      GrowableObjectArray::Handle(pending_extension_calls());
+  if (calls.IsNull()) {
+    calls ^= GrowableObjectArray::New(Heap::kOld);
+    ASSERT(!calls.IsNull());
+    set_pending_extension_calls(calls);
+  }
+  calls.Add(closure, Heap::kOld);
+}
+
+
 void Isolate::WakePauseEventHandler(Dart_Isolate isolate) {
   Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   MonitorLocker ml(iso->pause_loop_monitor_);
   ml.Notify();
 }
 
 
 void Isolate::PauseEventHandler() {
   // We are stealing a pause event (like a breakpoint) from the
   // embedder.  We don't know what kind of thread we are on -- it
@@ skipping 308 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart