Pass Thread into StackFrameIterator

runtime/vm/stack_frame.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_STACK_FRAME_H_
 #define VM_STACK_FRAME_H_
 
 #include "vm/allocation.h"
 #include "vm/object.h"
 #include "vm/stub_code.h"
@@ skipping 164 matching lines @@
 // It is the responsibility of users of StackFrameIterator to ensure that the
 // isolate given is not running concurrently on another thread.
 class StackFrameIterator : public ValueObject {
  public:
   static const bool kValidateFrames = true;
   static const bool kDontValidateFrames = false;
 
   // Iterators for iterating over all frames from the last ExitFrame to the
   // first EntryFrame.
   explicit StackFrameIterator(bool validate,
-                              Isolate* isolate = Isolate::Current());
+                              Isolate* isolate = Isolate::Current(),
+                              Thread* thread = Thread::Current());

[siva, 2015/10/20 21:06:14]

The explicit should have been removed when the isolate parameter was added.

I am wondering if we should get rid of the isolate parameter totally here and
derive isolate from thread_->isolate(), having both isolate and thread parameter
seems redundant and provides a possibility of getting these to be inconsistent.

   StackFrameIterator(uword last_fp, bool validate,
-                     Isolate* isolate = Isolate::Current());
+                     Isolate* isolate = Isolate::Current(),
+                     Thread* thread = Thread::Current());
 
   // Iterator for iterating over all frames from the current frame (given by its
   // fp, sp, and pc) to the first EntryFrame.
   StackFrameIterator(uword fp, uword sp, uword pc, bool validate,
-                     Isolate* isolate = Isolate::Current());
+                     Isolate* isolate = Isolate::Current(),
+                     Thread* thread = Thread::Current());
 
   // Checks if a next frame exists.
   bool HasNextFrame() const { return frames_.fp_ != 0; }
 
   // Get next frame.
   StackFrame* NextFrame();
 
   bool validate() const { return validate_; }
 
  private:
@@ skipping 41 matching lines @@
   // stack frames.
   void SetupLastExitFrameData();
   void SetupNextExitFrameData();
 
   bool validate_;  // Validate each frame as we traverse the frames.
   EntryFrame entry_;  // Singleton entry frame returned by NextEntryFrame().
   ExitFrame exit_;  // Singleton exit frame returned by NextExitFrame().
   FrameSetIterator frames_;
   StackFrame* current_frame_;  // Points to the current frame in the iterator.
   Isolate* isolate_;
+  Thread* thread_;
 
   DISALLOW_COPY_AND_ASSIGN(StackFrameIterator);
 };
 
 
 // Iterator for iterating over all dart frames (skips over exit frames,
 // entry frames and stub frames).
 // A DartFrameIterator can be initialized with an isolate other than the
 // current thread's isolate. Because this is generally a bad idea,
 // it is only allowed on Windows- where it is needed for the profiler.
 // It is the responsibility of users of DartFrameIterator to ensure that the
 // isolate given is not running concurrently on another thread.
 class DartFrameIterator : public ValueObject {
  public:
-  explicit DartFrameIterator(Isolate* isolate = Isolate::Current())
-      : frames_(StackFrameIterator::kDontValidateFrames, isolate) { }
+  DartFrameIterator(Isolate* isolate = Isolate::Current(),
+                    Thread* thread = Thread::Current())

[srdjan, 2015/10/20 20:59:26]

Pass in only thread and get isolate from thread->isolate(), here and elsewhere

+      : frames_(StackFrameIterator::kDontValidateFrames, isolate, thread) { }
   DartFrameIterator(uword last_fp,
-                    Isolate* isolate = Isolate::Current())
-      : frames_(last_fp, StackFrameIterator::kDontValidateFrames, isolate) { }
+                    Isolate* isolate = Isolate::Current(),
+                    Thread* thread = Thread::Current())
+      : frames_(last_fp, StackFrameIterator::kDontValidateFrames,
+                isolate, thread) { }
   DartFrameIterator(uword fp,
                     uword sp,
                     uword pc,
-                    Isolate* isolate = Isolate::Current())
-      : frames_(fp, sp, pc, StackFrameIterator::kDontValidateFrames, isolate) {
+                    Isolate* isolate = Isolate::Current(),
+                    Thread* thread = Thread::Current())
+      : frames_(fp, sp, pc,
+                StackFrameIterator::kDontValidateFrames, isolate, thread) {
   }
   // Get next dart frame.
   StackFrame* NextFrame() {
     StackFrame* frame = frames_.NextFrame();
     while (frame != NULL && !frame->IsDartFrame(frames_.validate())) {
       frame = frames_.NextFrame();
     }
     return frame;
   }
 
@@ skipping 41 matching lines @@
   uword pc_;
   GrowableArray<DeoptInstr*> deopt_instructions_;
   ObjectPool& object_table_;
 
   DISALLOW_COPY_AND_ASSIGN(InlinedFunctionsIterator);
 };
 
 }  // namespace dart
 
 #endif  // VM_STACK_FRAME_H_