- Landing https://codereview.chromium.org/293963008/

runtime/vm/debugger.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 "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 1160 matching lines @@
     }
   }
 }
 
 
 void Debugger::SetInternalBreakpoints(const Function& target_function) {
   if (target_function.is_native()) {
     // Can't instrument native functions.
     return;
   }
+  Isolate* isolate = Isolate::Current();
   if (!target_function.HasCode()) {
-    Compiler::CompileFunction(target_function);
+    Compiler::CompileFunction(isolate, target_function);
     // If there were any errors, ignore them silently and return without
     // adding breakpoints to target.
     if (!target_function.HasCode()) {
       return;
     }
   }
   // Hang on to the code object before deoptimizing, in case deoptimization
   // might cause the GC to run.
-  Code& code = Code::Handle(target_function.unoptimized_code());
+  Code& code = Code::Handle(isolate, target_function.unoptimized_code());
   ASSERT(!code.IsNull());
   DeoptimizeWorld();
   ASSERT(!target_function.HasOptimizedCode());
-  PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+  PcDescriptors& desc = PcDescriptors::Handle(isolate, code.pc_descriptors());
   for (intptr_t i = 0; i < desc.Length(); i++) {
     if (IsSafePoint(desc, i)) {
       CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
       if (bpt != NULL) {
         // There is already a breakpoint for this address. Make sure
         // it is enabled.
         bpt->Enable();
         continue;
       }
       bpt = new CodeBreakpoint(code, i);
@@ skipping 28 matching lines @@
   ActivationFrame* activation =
       new ActivationFrame(pc, frame->fp(), frame->sp(), code,
                           deopt_frame, deopt_frame_offset);
 
   // Is there a closure call at the current PC?
   //
   // We can't just check the callee_activation to see if it is a
   // closure function, because it may not be on the stack yet.
   bool is_closure_call = false;
   const PcDescriptors& pc_desc =
-      PcDescriptors::Handle(code.pc_descriptors());
+      PcDescriptors::Handle(isolate, code.pc_descriptors());
 
   for (int i = 0; i < pc_desc.Length(); i++) {
     if (pc_desc.PC(i) == pc &&
         pc_desc.DescriptorKind(i) == PcDescriptors::kClosureCall) {
       is_closure_call = true;
       break;
     }
   }
 
   // Recover the context for this frame.
@@ skipping 45 matching lines @@
 
   // Create the DeoptContext for this deoptimization.
   DeoptContext* deopt_context =
       new DeoptContext(frame, code,
                        DeoptContext::kDestIsAllocated,
                        NULL, NULL);
   isolate->set_deopt_context(deopt_context);
 
   deopt_context->FillDestFrame();
   deopt_context->MaterializeDeferredObjects();
-  const Array& dest_frame = Array::Handle(deopt_context->DestFrameAsArray());
+  const Array& dest_frame = Array::Handle(isolate,
+                                          deopt_context->DestFrameAsArray());
 
   isolate->set_deopt_context(NULL);
   delete deopt_context;
 
   return dest_frame.raw();
 }
 
 
 DebuggerStackTrace* Debugger::CollectStackTrace() {
   Isolate* isolate = Isolate::Current();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   StackFrameIterator iterator(false);
   ActivationFrame* current_activation = NULL;
-  Context& entry_ctx = Context::Handle(isolate->top_context());
+  Context& entry_ctx = Context::Handle(isolate, isolate->top_context());
   Code& code = Code::Handle(isolate);
   Code& inlined_code = Code::Handle(isolate);
   Array& deopt_frame = Array::Handle(isolate);
 
   for (StackFrame* frame = iterator.NextFrame();
        frame != NULL;
        frame = iterator.NextFrame()) {
     ASSERT(frame->IsValid());
     if (FLAG_trace_debugger_stacktrace) {
       OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n",
@@ skipping 10 matching lines @@
     } else if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       if (code.is_optimized()) {
         deopt_frame = DeoptimizeToArray(isolate, frame, code);
         for (InlinedFunctionsIterator it(code, frame->pc());
              !it.Done();
              it.Advance()) {
           inlined_code = it.code();
           if (FLAG_trace_debugger_stacktrace) {
             const Function& function =
-                Function::Handle(inlined_code.function());
+                Function::Handle(isolate, inlined_code.function());
             ASSERT(!function.IsNull());
             OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
                          function.ToFullyQualifiedCString());
           }
           intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
           current_activation = CollectDartFrame(isolate,
                                                 it.pc(),
                                                 frame,
                                                 inlined_code,
                                                 deopt_frame,
@@ skipping 1194 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart