DevTools: implement JavaScriptCallFrame binding based on v8 API

Source/bindings/core/v8/V8Debugger.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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "bindings/core/v8/V8Debugger.h"
 
 #include "bindings/core/v8/ScriptValue.h"
-#include "bindings/core/v8/V8JavaScriptCallFrame.h"
+#include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
+#include "bindings/core/v8/inspector/V8JavaScriptCallFrame.h"
 #include "core/inspector/JavaScriptCallFrame.h"
 #include "core/inspector/ScriptDebugListener.h"
 #include "platform/JSONValues.h"
 #include "wtf/Deque.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 #include "wtf/dtoa/utils.h"
 #include "wtf/text/CString.h"
 
@@ skipping 49 matching lines @@
 DEFINE_TRACE(V8Debugger)
 {
 }
 
 void V8Debugger::enable()
 {
     ASSERT(!enabled());
     v8::HandleScope scope(m_isolate);
     v8::Debug::SetDebugEventListener(&V8Debugger::v8DebugEventCallback, v8::External::New(m_isolate, this));
     m_debuggerContext.Reset(m_isolate, v8::Debug::GetDebugContext());
+    m_callFrameWrapperTemplate.Reset(m_isolate, V8JavaScriptCallFrame::createWrapperTemplate(m_isolate));
     compileDebuggerScript();
 }
 
 void V8Debugger::disable()
 {
     ASSERT(enabled());
     clearBreakpoints();
     m_debuggerScript.Reset();
     m_debuggerContext.Reset();
+    m_callFrameWrapperTemplate.Reset();
     v8::Debug::SetDebugEventListener(nullptr);
 }
 
 bool V8Debugger::enabled() const
 {
     return !m_debuggerScript.IsEmpty();
 }
 
 void V8Debugger::setContextDebugData(v8::Local<v8::Context> context, const String& contextDebugData)
 {
@@ skipping 276 matching lines @@
 
 PassRefPtrWillBeRawPtr<JavaScriptCallFrame> V8Debugger::toJavaScriptCallFrameUnsafe(const ScriptValue& value)
 {
     if (value.isEmpty())
         return nullptr;
     ScriptState* scriptState = value.scriptState();
     if (!scriptState || !scriptState->contextIsValid())
         return nullptr;
     ScriptState::Scope scope(scriptState);
     ASSERT(value.isObject());
-    return V8JavaScriptCallFrame::toImpl(v8::Local<v8::Object>::Cast(value.v8ValueUnsafe()));
+    return V8JavaScriptCallFrame::unwrap(v8::Local<v8::Object>::Cast(value.v8ValueUnsafe()));
 }
 
 PassRefPtrWillBeRawPtr<JavaScriptCallFrame> V8Debugger::wrapCallFrames(int maximumLimit, ScopeInfoDetails scopeDetails)
 {
     const int scopeBits = 2;
     static_assert(NoScopes < (1 << scopeBits), "there must be enough bits to encode ScopeInfoDetails");
 
     ASSERT(maximumLimit >= 0);
     int data = (maximumLimit << scopeBits) | scopeDetails;
     v8::Local<v8::Value> currentCallFrameV8;
@@ skipping 18 matching lines @@
 
     // 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 ScriptValue();
 
     RefPtrWillBeRawPtr<JavaScriptCallFrame> currentCallFrame = wrapCallFrames(0, scopeDetails);
     if (!currentCallFrame)
         return ScriptValue();
 
+    v8::Local<v8::FunctionTemplate> wrapperTemplate = v8::Local<v8::FunctionTemplate>::New(m_isolate, m_callFrameWrapperTemplate);
     ScriptState* scriptState = m_pausedScriptState ? m_pausedScriptState.get() : ScriptState::current(m_isolate);
     ScriptState::Scope scope(scriptState);
-    return ScriptValue(scriptState, toV8(currentCallFrame.release(), scriptState->context()->Global(), m_isolate));
+    v8::Local<v8::Object> wrapper = V8JavaScriptCallFrame::wrap(wrapperTemplate, scriptState->context(), currentCallFrame.release());
+    return ScriptValue(scriptState, wrapper);
 }
 
 ScriptValue V8Debugger::currentCallFrames()
 {
     return currentCallFramesInner(AllScopes);
 }
 
 ScriptValue V8Debugger::currentCallFramesForAsyncStack()
 {
     return currentCallFramesInner(FastAsyncScopes);
@@ skipping 284 matching lines @@
     return callDebuggerMethod("setFunctionVariableValue", 4, argv);
 }
 
 
 bool V8Debugger::isPaused()
 {
     return m_pausedScriptState;
 }
 
 } // namespace blink