Revert of [runtime] Change JavaScriptFrame::GetFunctions interface.

src/accessors.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/accessors.h"
 
 #include "src/api.h"
 #include "src/contexts.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
@@ skipping 826 matching lines @@
   }
 
   // Return the freshly allocated arguments object.
   return arguments;
 }
 
 
 static int FindFunctionInFrame(JavaScriptFrame* frame,
                                Handle<JSFunction> function) {
   DisallowHeapAllocation no_allocation;
-  List<FrameSummary> frames(2);
-  frame->Summarize(&frames);
-  for (int i = frames.length() - 1; i >= 0; i--) {
-    if (*frames[i].function() == *function) return i;
+  List<JSFunction*> functions(2);
+  frame->GetFunctions(&functions);
+  for (int i = functions.length() - 1; i >= 0; i--) {
+    if (functions[i] == *function) return i;
   }
   return -1;
 }
 
 
 namespace {
 
 Handle<Object> GetFunctionArguments(Isolate* isolate,
                                     Handle<JSFunction> function) {
   // Find the top invocation of the function by traversing frames.
@@ skipping 83 matching lines @@
 
 static inline bool AllowAccessToFunction(Context* current_context,
                                          JSFunction* function) {
   return current_context->HasSameSecurityTokenAs(function->context());
 }
 
 
 class FrameFunctionIterator {
  public:
   FrameFunctionIterator(Isolate* isolate, const DisallowHeapAllocation& promise)
-      : isolate_(isolate), frame_iterator_(isolate), frames_(2), index_(0) {
-    GetFrames();
+      : isolate_(isolate),
+        frame_iterator_(isolate),
+        functions_(2),
+        index_(0) {
+    GetFunctions();
   }
   JSFunction* next() {
     while (true) {
-      if (frames_.length() == 0) return NULL;
-      JSFunction* next_function = *frames_[index_].function();
+      if (functions_.length() == 0) return NULL;
+      JSFunction* next_function = functions_[index_];
       index_--;
       if (index_ < 0) {
-        GetFrames();
+        GetFunctions();
       }
       // Skip functions from other origins.
       if (!AllowAccessToFunction(isolate_->context(), next_function)) continue;
       return next_function;
     }
   }
 
   // Iterate through functions until the first occurence of 'function'.
   // Returns true if 'function' is found, and false if the iterator ends
   // without finding it.
   bool Find(JSFunction* function) {
     JSFunction* next_function;
     do {
       next_function = next();
       if (next_function == function) return true;
     } while (next_function != NULL);
     return false;
   }
 
  private:
-  void GetFrames() {
-    frames_.Rewind(0);
+  void GetFunctions() {
+    functions_.Rewind(0);
     if (frame_iterator_.done()) return;
     JavaScriptFrame* frame = frame_iterator_.frame();
-    frame->Summarize(&frames_);
-    DCHECK(frames_.length() > 0);
+    frame->GetFunctions(&functions_);
+    DCHECK(functions_.length() > 0);
     frame_iterator_.Advance();
-    index_ = frames_.length() - 1;
+    index_ = functions_.length() - 1;
   }
   Isolate* isolate_;
   JavaScriptFrameIterator frame_iterator_;
-  List<FrameSummary> frames_;
+  List<JSFunction*> functions_;
   int index_;
 };
 
 
 MaybeHandle<JSFunction> FindCaller(Isolate* isolate,
                                    Handle<JSFunction> function) {
   DisallowHeapAllocation no_allocation;
   FrameFunctionIterator it(isolate, no_allocation);
   if (function->shared()->native()) {
     return MaybeHandle<JSFunction>();
@@ skipping 237 matching lines @@
 Handle<AccessorInfo> Accessors::ErrorStackInfo(Isolate* isolate,
                                                PropertyAttributes attributes) {
   Handle<AccessorInfo> info =
       MakeAccessor(isolate, isolate->factory()->stack_string(),
                    &ErrorStackGetter, &ErrorStackSetter, attributes);
   return info;
 }
 
 }  // namespace internal
 }  // namespace v8