Move Error methods to C++

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 311 matching lines @@
     for (int i = 0; i < cur_position; i++) {
       new_elements->set(i, elements->get(i));
     }
     elements = new_elements;
   }
   DCHECK(new_size <= elements->length());
   return elements;
 }
 
 class StackTraceHelper {
+ private:
+  enum FrameSkipMode {
+    SKIP_FIRST,
+    SKIP_UNTIL_SEEN,
+    SKIP_NONE,
+  };
+
  public:
   StackTraceHelper(Isolate* isolate, Handle<Object> caller)
       : isolate_(isolate), caller_(caller) {
-    // If the caller parameter is a function we skip frames until we're
-    // under it before starting to collect.
-    seen_caller_ = !caller->IsJSFunction();
+    // The caller parameter can be used to skip a specific set of frames in the
+    // stack trace. It can be:
+    // * null, when called from a standard error constructor. We unconditionally
+    //   skip the top frame, which is always a builtin-exit frame for the error
+    //   constructor builtin.
+    // * a JSFunction, when called by the user from Error.captureStackTrace().
+    //   We skip each frame until encountering the caller function.
+    // * For any other value, all frames are included in the trace.
+    if (caller_.is_null()) {
+      mode_ = SKIP_FIRST;
+      skip_next_frame_ = true;
+    } else if (caller_->IsJSFunction()) {
+      mode_ = SKIP_UNTIL_SEEN;
+      skip_next_frame_ = true;
+    } else {
+      mode_ = SKIP_NONE;
+      skip_next_frame_ = false;
+    }
     encountered_strict_function_ = false;
     sloppy_frames_ = 0;
   }
 
   // The stack trace API should not expose receivers and function
   // objects on frames deeper than the top-most one with a strict mode
   // function. The number of sloppy frames is stored as first element in
   // the result array.
   void CountSloppyFrames(JSFunction* fun) {
     if (!encountered_strict_function_) {
       if (is_strict(fun->shared()->language_mode())) {
         encountered_strict_function_ = true;
       } else {
         sloppy_frames_++;
       }
     }
   }
 
   // Determines whether the given stack frame should be displayed in a stack
   // trace.
   bool IsVisibleInStackTrace(JSFunction* fun) {
-    return IsAfterCaller(fun) && IsNotInNativeScript(fun) &&
+    return ShouldIncludeFrame(fun) && IsNotInNativeScript(fun) &&
            IsInSameSecurityContext(fun);
   }
 
   int sloppy_frames() const { return sloppy_frames_; }
 
  private:
-  // The caller is the error constructor that asked
-  // for the stack trace to be collected.  The first time a construct
-  // call to this function is encountered it is skipped.  The seen_caller
-  // in/out parameter is used to remember if the caller has been seen
-  // yet.
-  bool IsAfterCaller(JSFunction* fun) {
-    if ((fun == *caller_) && !(seen_caller_)) {
-      seen_caller_ = true;
-      return false;
+  // This mechanism excludes a number of uninteresting frames from the stack
+  // trace. This can be be the first frame (which will be a builtin-exit frame
+  // for the error constructor builtin) or every frame until encountering a
+  // user-specified function.
+  bool ShouldIncludeFrame(JSFunction* fun) {
+    switch (mode_) {
+      case SKIP_NONE:
+        return true;
+      case SKIP_FIRST:
+        if (!skip_next_frame_) return true;
+        skip_next_frame_ = false;
+        return false;
+      case SKIP_UNTIL_SEEN:
+        if (skip_next_frame_ && (fun == *caller_)) {
+          skip_next_frame_ = false;
+          return false;
+        }
+        return !skip_next_frame_;
     }
-    // Skip all frames until we've seen the caller.
-    if (!seen_caller_) return false;
-    return true;
+    UNREACHABLE();
+    return false;
   }
 
   bool IsNotInNativeScript(JSFunction* fun) {
     // Functions defined in native scripts are not visible unless directly
     // exposed, in which case the native flag is set.
     // The --builtins-in-stack-traces command line flag allows including
     // internal call sites in the stack trace for debugging purposes.
     if (!FLAG_builtins_in_stack_traces && fun->shared()->IsBuiltin()) {
       return fun->shared()->native();
     }
     return true;
   }
 
   bool IsInSameSecurityContext(JSFunction* fun) {
     return isolate_->context()->HasSameSecurityTokenAs(fun->context());
   }
 
   Isolate* isolate_;
+
+  FrameSkipMode mode_;
   Handle<Object> caller_;
+  bool skip_next_frame_;
 
-  bool seen_caller_;
   int sloppy_frames_;
   bool encountered_strict_function_;
 };
 
 Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSReceiver> error_object,
                                                 Handle<Object> caller) {
   // Get stack trace limit.
   Handle<JSObject> error = error_function();
   Handle<String> stackTraceLimit =
       factory()->InternalizeUtf8String("stackTraceLimit");
@@ skipping 2675 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8