Does anyone need copy constructor for StackFrameIterator?

src/frames.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 73 matching lines @@
       thread_(use_top ? Top::GetCurrentThread() : NULL),
       fp_(use_top ? NULL : fp), sp_(sp),
       advance_(use_top ? &StackFrameIterator::AdvanceWithHandler :
                &StackFrameIterator::AdvanceWithoutHandler) {
   if (use_top || fp != NULL) {
     Reset();
   }
   JavaScriptFrame_.DisableHeapAccess();
 }
 
+StackFrameIterator::StackFrameIterator(const StackFrameIterator& original)
+    : STACK_FRAME_TYPE_LIST(INITIALIZE_SINGLETON)
+      frame_(NULL) {
+  this->operator=(original);
+}
+
+void StackFrameIterator::operator =(const StackFrameIterator& original) {
+  this->frame_ = this->SingletonFor(original.frame_->type());
+  this->frame_->state_ = original.frame_->state_;
+
+  this->handler_ = original.handler_;
+  this->thread_ = original.thread_;
+  this->fp_ = original.fp_;
+  this->sp_ = original.sp_;
+  this->advance_ = original.advance_;
+  this->JavaScriptFrame_.disable_heap_access_ =
+      original.JavaScriptFrame_.disable_heap_access_;
+}
+
 #undef INITIALIZE_SINGLETON
 
 
 void StackFrameIterator::AdvanceWithHandler() {
   ASSERT(!done());
   // Compute the state of the calling frame before restoring
   // callee-saved registers and unwinding handlers. This allows the
   // frame code that computes the caller state to access the top
   // handler and the value of any callee-saved register if needed.
   StackFrame::State state;
@@ skipping 60 matching lines @@
     case StackFrame::NONE: return NULL;
     STACK_FRAME_TYPE_LIST(FRAME_TYPE_CASE)
     default: break;
   }
   return result;
 
 #undef FRAME_TYPE_CASE
 }
 
 
+bool operator==(const StackFrameIterator& one,
+    const StackFrameIterator& another) {
+  return one.frame()->id() == another.frame()->id();
+}
+
+
 // -------------------------------------------------------------------------
 
 
 StackTraceFrameIterator::StackTraceFrameIterator() {
   if (!done() && !IsValidFrame()) Advance();
 }
 
 
 void StackTraceFrameIterator::Advance() {
   while (true) {
@@ skipping 575 matching lines @@
         reg_code[i++] = r;
 
     ASSERT(i == kNumJSCallerSaved);
   }
   ASSERT(0 <= n && n < kNumJSCallerSaved);
   return reg_code[n];
 }
 
 
 } }  // namespace v8::internal