Revert of Refactor SharedFunctionInfo::IsBuiltin.

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 340 matching lines @@
   bool IsStrictFrame(JSFunction* fun) {
     if (!encountered_strict_function_) {
       encountered_strict_function_ = is_strict(fun->shared()->language_mode());
     }
     return encountered_strict_function_;
   }
 
   // Determines whether the given stack frame should be displayed in a stack
   // trace.
   bool IsVisibleInStackTrace(JSFunction* fun) {
-    return ShouldIncludeFrame(fun) && IsNotHidden(fun) &&
+    return ShouldIncludeFrame(fun) && IsNotInNativeScript(fun) &&
            IsInSameSecurityContext(fun);
   }
 
  private:
   // 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_;
     }
     UNREACHABLE();
     return false;
   }
 
-  bool IsNotHidden(JSFunction* fun) {
-    // Functions defined not in user scripts are not visible unless directly
+  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()->IsUserJavaScript()) {
+    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_;
@@ skipping 3083 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8