[DevTools] Move wrapCallFrames from InjectedScriptSource.js to native

third_party/WebKit/Source/platform/v8_inspector/V8DebuggerImpl.cpp

 /*
  * Copyright (c) 2010-2011 Google Inc. 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
@@ skipping 18 matching lines @@
  */
 
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/Atomics.h"
 #include "platform/v8_inspector/DebuggerScript.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.h"
-#include "platform/v8_inspector/V8JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 
 namespace blink {
 
 namespace {
 const char stepIntoV8MethodName[] = "stepIntoStatement";
 const char stepOutV8MethodName[] = "stepOutOfFunction";
@@ skipping 33 matching lines @@
 V8DebuggerImpl::~V8DebuggerImpl()
 {
 }
 
 void V8DebuggerImpl::enable()
 {
     ASSERT(!enabled());
     v8::HandleScope scope(m_isolate);
     v8::Debug::SetDebugEventListener(m_isolate, &V8DebuggerImpl::v8DebugEventCallback, v8::External::New(m_isolate, this));
     m_debuggerContext.Reset(m_isolate, v8::Debug::GetDebugContext(m_isolate));
-    m_callFrameWrapperTemplate.Reset(m_isolate, V8JavaScriptCallFrame::createWrapperTemplate(m_isolate));
     compileDebuggerScript();
 }
 
 void V8DebuggerImpl::disable()
 {
     ASSERT(enabled());
     clearBreakpoints();
     m_debuggerScript.Reset();
     m_debuggerContext.Reset();
-    m_callFrameWrapperTemplate.Reset();
     v8::Debug::SetDebugEventListener(m_isolate, nullptr);
 }
 
 bool V8DebuggerImpl::enabled() const
 {
     return !m_debuggerScript.IsEmpty();
 }
 
 void V8Debugger::setContextDebugData(v8::Local<v8::Context> context, const String16& type, int contextGroupId)
 {
@@ skipping 278 matching lines @@
 void V8DebuggerImpl::clearStepping()
 {
     ASSERT(enabled());
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Value> argv[] = { v8::Undefined(m_isolate) };
     callDebuggerMethod("clearStepping", 0, argv);
 }
 
-bool V8DebuggerImpl::setScriptSource(const String16& sourceID, const String16& newContent, bool preview, ErrorString* error, Maybe<protocol::Debugger::SetScriptSourceError>* errorData, v8::Global<v8::Object>* newCallFrames, Maybe<bool>* stackChanged)
+bool V8DebuggerImpl::setScriptSource(const String16& sourceID, const String16& newContent, bool preview, ErrorString* error, Maybe<protocol::Debugger::SetScriptSourceError>* errorData, OwnPtr<JavaScriptCallFrame>* newCallFrames, Maybe<bool>* stackChanged)
 {
     class EnableLiveEditScope {
     public:
         explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate)
         {
             v8::Debug::SetLiveEditEnabled(m_isolate, true);
             inLiveEditScope = true;
         }
         ~EnableLiveEditScope()
         {
@@ skipping 31 matching lines @@
     }
     ASSERT(!v8result.IsEmpty());
     v8::Local<v8::Object> resultTuple = v8result->ToObject(m_isolate);
     int code = static_cast<int>(resultTuple->Get(0)->ToInteger(m_isolate)->Value());
     switch (code) {
     case 0:
         {
             *stackChanged = resultTuple->Get(1)->BooleanValue();
             // Call stack may have changed after if the edited function was on the stack.
             if (!preview && isPaused())
-                newCallFrames->Reset(m_isolate, currentCallFrames());
+                *newCallFrames = currentCallFrames();
             return true;
         }
     // Compile error.
     case 1:
         {
             *errorData = protocol::Debugger::SetScriptSourceError::create()
                 .setMessage(toProtocolStringWithTypeCheck(resultTuple->Get(2)))
                 .setLineNumber(resultTuple->Get(3)->ToInteger(m_isolate)->Value())
                 .setColumnNumber(resultTuple->Get(4)->ToInteger(m_isolate)->Value()).build();
             return false;
@@ skipping 23 matching lines @@
     } else {
         v8::Local<v8::Value> argv[] = { m_executionState };
         currentCallFrameV8 = callDebuggerMethod("currentCallFrame", WTF_ARRAY_LENGTH(argv), argv).ToLocalChecked();
     }
     ASSERT(!currentCallFrameV8.IsEmpty());
     if (!currentCallFrameV8->IsObject())
         return nullptr;
     return JavaScriptCallFrame::create(debuggerContext(), v8::Local<v8::Object>::Cast(currentCallFrameV8));
 }
 
-v8::Local<v8::Object> V8DebuggerImpl::currentCallFrames()
+PassOwnPtr<JavaScriptCallFrame> V8DebuggerImpl::currentCallFrames()
 {
     if (!m_isolate->InContext())
-        return v8::Local<v8::Object>();
+        return nullptr;
 
     // Filter out stack traces entirely consisting of V8's internal scripts.
     v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(m_isolate, 1);
     if (!stackTrace->GetFrameCount())
-        return v8::Local<v8::Object>();
+        return nullptr;
 
-    OwnPtr<JavaScriptCallFrame> currentCallFrame = wrapCallFrames();
-    if (!currentCallFrame)
-        return v8::Local<v8::Object>();
-
-    v8::Local<v8::FunctionTemplate> wrapperTemplate = v8::Local<v8::FunctionTemplate>::New(m_isolate, m_callFrameWrapperTemplate);
-    v8::Local<v8::Context> context = m_pausedContext.IsEmpty() ? m_isolate->GetCurrentContext() : m_pausedContext;
-    v8::Context::Scope scope(context);
-    v8::Local<v8::Object> wrapper = V8JavaScriptCallFrame::wrap(wrapperTemplate, context, currentCallFrame.release());
-    return wrapper;
+    return wrapCallFrames();
 }
 
 PassOwnPtr<JavaScriptCallFrame> V8DebuggerImpl::callFrame(int index)
 {
     if (!m_isolate->InContext())
         return nullptr;
     v8::HandleScope handleScope(m_isolate);
 
     v8::Local<v8::Value> currentCallFrameV8;
     if (m_executionState.IsEmpty()) {
@@ skipping 368 matching lines @@
 }
 
 v8::Local<v8::Context> V8DebuggerImpl::regexContext()
 {
     if (m_regexContext.IsEmpty())
         m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
     return m_regexContext.Get(m_isolate);
 }
 
 } // namespace blink