- Remove deprecated StackZone constructor with Isolate parameter.

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 77 matching lines @@
 // equivalent to setting --enable-asserts and --enable-type-checks.
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     enable_checked_mode,
                     "Enable checked mode.");
 
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     checked,
                     "Enable checked mode.");
 
 
-// Quick access to the locally defined isolate() method.
+// Quick access to the locally defined thread() and isolate() methods.
+#define T (thread())
 #define I (isolate())
 
 #if defined(DEBUG)
 // Helper class to ensure that a live origin_id is never reused
 // and assigned to an isolate.
 class VerifyOriginId : public IsolateVisitor {
  public:
   explicit VerifyOriginId(Dart_Port id) : id_(id) {}
 
   void VisitIsolate(Isolate* isolate) {
@@ skipping 390 matching lines @@
     } else {
       ASSERT(result.IsNull());
     }
   }
   return success;
 }
 
 
 void IsolateMessageHandler::NotifyPauseOnStart() {
   if (Service::debug_stream.enabled()) {
-    StartIsolateScope start_isolate(isolate());
-    StackZone zone(I);
-    HandleScope handle_scope(thread());
-    ServiceEvent pause_event(isolate(), ServiceEvent::kPauseStart);
+    StartIsolateScope start_isolate(I);
+    StackZone zone(T);
+    HandleScope handle_scope(T);
+    ServiceEvent pause_event(I, ServiceEvent::kPauseStart);
     Service::HandleEvent(&pause_event);
   } else if (FLAG_trace_service) {
     OS::Print("vm-service: Dropping event of type PauseStart (%s)\n",
-              isolate()->name());
+              I->name());
   }
 }
 
 
 void IsolateMessageHandler::NotifyPauseOnExit() {
   if (Service::debug_stream.enabled()) {
-    StartIsolateScope start_isolate(isolate());
-    StackZone zone(I);
-    HandleScope handle_scope(thread());
-    ServiceEvent pause_event(isolate(), ServiceEvent::kPauseExit);
+    StartIsolateScope start_isolate(I);
+    StackZone zone(T);
+    HandleScope handle_scope(T);
+    ServiceEvent pause_event(I, ServiceEvent::kPauseExit);
     Service::HandleEvent(&pause_event);
   } else if (FLAG_trace_service) {
     OS::Print("vm-service: Dropping event of type PauseExit (%s)\n",
-              isolate()->name());
+              I->name());
   }
 }
 
 
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
@@ skipping 724 matching lines @@
   IsolateSpawnState* state = NULL;
   Thread* thread = Thread::Current();
   {
     // TODO(turnidge): Is this locking required here at all anymore?
     MutexLocker ml(isolate->mutex());
     state = isolate->spawn_state();
   }
   {
     StartIsolateScope start_scope(isolate);
     ASSERT(thread->isolate() == isolate);
-    StackZone zone(isolate);
+    StackZone zone(thread);
     HandleScope handle_scope(thread);
 
     // If particular values were requested for this newly spawned isolate, then
     // they are set here before the isolate starts executing user code.
     isolate->SetErrorsFatal(state->errors_are_fatal());
     if (state->on_exit_port() != ILLEGAL_PORT) {
       const SendPort& listener =
           SendPort::Handle(SendPort::New(state->on_exit_port()));
       isolate->AddExitListener(listener, Instance::null_instance());
     }
@@ skipping 80 matching lines @@
 
 
 static void ShutdownIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   {
     // Print the error if there is one.  This may execute dart code to
     // print the exception object, so we need to use a StartIsolateScope.
     Thread* thread = Thread::Current();
     StartIsolateScope start_scope(isolate);
     ASSERT(thread->isolate() == isolate);
-    StackZone zone(isolate);
+    StackZone zone(thread);
     HandleScope handle_scope(thread);
     Error& error = Error::Handle();
     error = isolate->object_store()->sticky_error();
     if (!error.IsNull() && !error.IsUnwindError()) {
       OS::PrintErr("in ShutdownIsolate: %s\n", error.ToErrorCString());
     }
     Dart::RunShutdownCallback();
   }
   {
     // Shut the isolate down.
@@ skipping 106 matching lines @@
     // The VM isolate keeps all objects marked.
     heap_->Verify(this == Dart::vm_isolate() ? kRequireMarked : kForbidMarked);
   }
 #endif  // DEBUG
 
   Thread* thread = Thread::Current();
 
   // First, perform higher-level cleanup that may need to allocate.
   {
     // Ensure we have a zone and handle scope so that we can call VM functions.
-    StackZone stack_zone(this);
+    StackZone stack_zone(thread);
     HandleScope handle_scope(thread);
 
     // Write out the coverage data if collection has been enabled.
     CodeCoverage::Write(this);
   }
 
   // Remove this isolate from the list *before* we start tearing it down, to
   // avoid exposing it in a state of decay.
   RemoveIsolateFromList(this);
 
   if (heap_ != NULL) {
     // Wait for any concurrent GC tasks to finish before shutting down.
     // TODO(koda): Support faster sweeper shutdown (e.g., after current page).
     PageSpace* old_space = heap_->old_space();
     MonitorLocker ml(old_space->tasks_lock());
     while (old_space->tasks() > 0) {
       ml.Wait();
     }
   }
 
   // Then, proceed with low-level teardown.
   {
     // Ensure we have a zone and handle scope so that we can call VM functions,
     // but we no longer allocate new heap objects.
-    StackZone stack_zone(this);
+    StackZone stack_zone(thread);
     HandleScope handle_scope(thread);
     NoSafepointScope no_safepoint_scope;
 
     if (compiler_stats_ != NULL) {
       compiler_stats()->Print();
     }
 
     // Notify exit listeners that this isolate is shutting down.
     if (object_store() != NULL) {
       NotifyExitListeners();
@@ skipping 603 matching lines @@
       previous->next_ = current->next_;
       return;
     }
     previous = current;
     current = current->next_;
   }
   UNREACHABLE();
 }
 
 
-template<class T>
-T* Isolate::AllocateReusableHandle() {
-  T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
-  T::initializeHandle(handle, T::null());
+template<class C>
+C* Isolate::AllocateReusableHandle() {
+  C* handle = reinterpret_cast<C*>(reusable_handles_.AllocateScopedHandle());
+  C::initializeHandle(handle, C::null());
   return handle;
 }
 
 
 static RawInstance* DeserializeObject(Thread* thread,
                                       uint8_t* obj_data,
                                       intptr_t obj_len) {
   if (obj_data == NULL) {
     return Instance::null();
   }
@@ skipping 186 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart