[DevTools] Move last inspected objects to V8InspectorSessionImpl

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

 // Copyright 2016 The Chromium 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 "platform/v8_inspector/V8Console.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8ProfilerAgentImpl.h"
+#include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/ConsoleAPITypes.h"
 #include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 172 matching lines @@
     }
 
     V8DebuggerAgentImpl* debuggerAgent()
     {
         if (V8InspectorSessionImpl* session = currentSession()) {
             if (session && session->debuggerAgentImpl()->enabled())
                 return session->debuggerAgentImpl();
         }
         return nullptr;
     }
+
+    V8InspectorSessionImpl* currentSession()
+    {
+        InspectedContext* inspectedContext = ensureInspectedContext();
+        if (!inspectedContext)
+            return nullptr;
+        return inspectedContext->debugger()->sessionForContextGroup(inspectedContext->contextGroupId());
+    }
+
 private:
     const v8::FunctionCallbackInfo<v8::Value>& m_info;
     v8::Isolate* m_isolate;
     v8::Local<v8::Context> m_context;
     v8::Local<v8::Object> m_console;
     InspectedContext* m_inspectedContext;
     V8DebuggerClient* m_debuggerClient;
 
     bool checkAndSetPrivateFlagOnConsole(const char* name, bool defaultValue)
     {
         v8::Local<v8::Object> console = ensureConsole();
         v8::Local<v8::Private> key = v8::Private::ForApi(m_isolate, toV8StringInternalized(m_isolate, name));
         v8::Local<v8::Value> flagValue;
         if (!console->GetPrivate(m_context, key).ToLocal(&flagValue))
             return defaultValue;
         ASSERT(flagValue->IsUndefined() || flagValue->IsBoolean());
         if (flagValue->IsBoolean()) {
             ASSERT(flagValue.As<v8::Boolean>()->Value());
             return true;
         }
         if (!console->SetPrivate(m_context, key, v8::True(m_isolate)).FromMaybe(false))
             return defaultValue;
         return false;
     }
-
-    V8InspectorSessionImpl* currentSession()
-    {
-        InspectedContext* inspectedContext = ensureInspectedContext();
-        if (!inspectedContext)
-            return nullptr;
-        return inspectedContext->debugger()->sessionForContextGroup(inspectedContext->contextGroupId());
-    }
 };
 
 v8::MaybeLocal<v8::Object> createObjectWithClassName(V8DebuggerImpl* debugger, v8::Local<v8::Context> context, const char* className)
 {
     v8::Isolate* isolate = debugger->isolate();
     v8::Local<v8::FunctionTemplate> functionTemplate;
     String16 functionTemplateName = String16("V8Console#") + className;
     if (!debugger->functionTemplate(functionTemplateName).ToLocal(&functionTemplate)) {
         functionTemplate = v8::FunctionTemplate::New(isolate);
         functionTemplate->SetClassName(toV8StringInternalized(isolate, className));
@@ skipping 325 matching lines @@
 void V8Console::lastEvaluationResultCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ConsoleHelper helper(info);
     InspectedContext* context = helper.ensureInspectedContext();
     if (!context)
         return;
     if (InjectedScript* injectedScript = context->getInjectedScript())
         info.GetReturnValue().Set(injectedScript->lastEvaluationResult());
 }
 
+void V8Console::inspectedObject(const v8::FunctionCallbackInfo<v8::Value>& info, unsigned num)
+{
+    ASSERT(num < V8InspectorSessionImpl::kInspectedObjectBufferSize);
+    ConsoleHelper helper(info);
+    if (V8InspectorSessionImpl* session = helper.currentSession()) {
+        V8RuntimeAgent::Inspectable* object = session->inspectedObject(num);
+        v8::Isolate* isolate = info.GetIsolate();
+        if (object)
+            info.GetReturnValue().Set(object->get(isolate->GetCurrentContext()));
+        else
+            info.GetReturnValue().Set(v8::Undefined(isolate));
+    }
+}
+
 v8::MaybeLocal<v8::Object> V8Console::createConsole(InspectedContext* inspectedContext, bool hasMemoryAttribute)
 {
     v8::Local<v8::Context> context = inspectedContext->context();
     v8::Isolate* isolate = context->GetIsolate();
     v8::MicrotasksScope microtasksScope(isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
 
     v8::Local<v8::Object> console;
     if (!createObjectWithClassName(inspectedContext->debugger(), context, "Console").ToLocal(&console))
         return v8::MaybeLocal<v8::Object>();
 
@@ skipping 50 matching lines @@
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "clear", V8Console::clearCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "table", V8Console::tableCallback);
 
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "keys", V8Console::keysCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "values", V8Console::valuesCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "debug", V8Console::debugFunctionCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "undebug", V8Console::undebugFunctionCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "monitor", V8Console::monitorFunctionCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "unmonitor", V8Console::unmonitorFunctionCallback);
     createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$_", V8Console::lastEvaluationResultCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$0", V8Console::inspectedObject0);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$1", V8Console::inspectedObject1);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$2", V8Console::inspectedObject2);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$3", V8Console::inspectedObject3);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$4", V8Console::inspectedObject4);
 
     commandLineAPI->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, inspectedContext));
     return commandLineAPI;
 }
 
 void V8Console::clearInspectedContextIfNeeded(v8::Local<v8::Context> context, v8::Local<v8::Object> console)
 {
     v8::Isolate* isolate = context->GetIsolate();
     console->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, nullptr));
 }
@@ skipping 16 matching lines @@
     DEFINE_STATIC_LOCAL(protocol::HashSet<String16>, getters, ());
     if (getters.size() == 0) {
         const char* members[] = { "$0", "$1", "$2", "$3", "$4", "$_" };
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(members); ++i)
             getters.add(members[i]);
     }
     return getters.find(name) != getters.end();
 }
 
 } // namespace blink