Remove several JSFunction delegator functions.

src/runtime/runtime-debug.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/debug/debug.h"
 #include "src/debug/debug-evaluate.h"
 #include "src/debug/debug-frames.h"
@@ skipping 433 matching lines @@
   if (id == StackFrame::NO_ID) {
     // If there is no JavaScript stack frame count is 0.
     return Smi::FromInt(0);
   }
 
   for (JavaScriptFrameIterator it(isolate, id); !it.done(); it.Advance()) {
     List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
     it.frame()->Summarize(&frames);
     for (int i = frames.length() - 1; i >= 0; i--) {
       // Omit functions from native and extension scripts.
-      if (frames[i].function()->IsSubjectToDebugging()) n++;
+      if (frames[i].function()->shared()->IsSubjectToDebugging()) n++;
     }
   }
   return Smi::FromInt(n);
 }
 
 
 static const int kFrameDetailsFrameIdIndex = 0;
 static const int kFrameDetailsReceiverIndex = 1;
 static const int kFrameDetailsFunctionIndex = 2;
 static const int kFrameDetailsArgumentCountIndex = 3;
@@ skipping 57 matching lines @@
                           isolate);
 
   // Find source position in unoptimized code.
   int position = frame_inspector.GetSourcePosition();
 
   // Check for constructor frame.
   bool constructor = frame_inspector.IsConstructor();
 
   // Get scope info and read from it for local variable information.
   Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
-  RUNTIME_ASSERT(function->IsSubjectToDebugging());
+  RUNTIME_ASSERT(function->shared()->IsSubjectToDebugging());
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
   DCHECK(*scope_info != ScopeInfo::Empty(isolate));
 
   // Get the locals names and values into a temporary array.
   int local_count = scope_info->LocalCount();
   for (int slot = 0; slot < scope_info->LocalCount(); ++slot) {
     // Hide compiler-introduced temporary variables, whether on the stack or on
     // the context.
     if (scope_info->LocalIsSynthetic(slot)) local_count--;
@@ skipping 155 matching lines @@
     details->set(details_index++, locals->get(i));
   }
 
   // Add the value being returned.
   if (at_return) {
     details->set(details_index++, *return_value);
   }
 
   // Add the receiver (same as in function frame).
   Handle<Object> receiver(it.frame()->receiver(), isolate);
-  DCHECK(!function->IsBuiltin());
+  DCHECK(!function->shared()->IsBuiltin());
   if (!receiver->IsJSObject() && is_sloppy(shared->language_mode())) {
     // If the receiver is not a JSObject and the function is not a builtin or
     // strict-mode we have hit an optimization where a value object is not
     // converted into a wrapped JS objects. To hide this optimization from the
     // debugger, we wrap the receiver by creating correct wrapper object based
     // on the function's native context.
     // See ECMA-262 6.0, 9.2.1.2, 6 b iii.
     if (receiver->IsUndefined()) {
       receiver = handle(function->global_proxy());
     } else {
@@ skipping 912 matching lines @@
   CONVERT_ARG_CHECKED(Object, object, 0);
   RUNTIME_ASSERT(object->IsJSFunction() || object->IsJSGeneratorObject());
   // We do not step into the callback if it's a builtin other than a bound,
   // or not even a function.
   JSFunction* fun;
   if (object->IsJSFunction()) {
     fun = JSFunction::cast(object);
   } else {
     fun = JSGeneratorObject::cast(object)->function();
   }
-  return isolate->heap()->ToBoolean(fun->IsSubjectToDebugging() ||
+  return isolate->heap()->ToBoolean(fun->shared()->IsSubjectToDebugging() ||
                                     fun->shared()->bound());
 }
 
 
 void FloodDebugSubjectWithOneShot(Debug* debug, Handle<JSFunction> function) {
-  if (function->IsSubjectToDebugging() || function->shared()->bound()) {
+  if (function->shared()->IsSubjectToDebugging() ||
+      function->shared()->bound()) {
     // When leaving the function, step out has been activated, but not performed
     // if we do not leave the builtin.  To be able to step into the function
     // again, we need to clear the step out at this point.
     debug->ClearStepOut();
     debug->FloodWithOneShotGeneric(function);
   }
 }
 
 
 // Set one shot breakpoints for the callback function that is passed to a
@@ skipping 77 matching lines @@
   return *isolate->factory()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8