[inspector] console get all information from inspector when needed

With this CL we don't need to store reference to InspectedContext inside of JavaScript console object and able to get all required information from callback data.
It allows us to implement console methods without taking in account how and where we create and store these methods:
- later we can move console object implementation to builtins..
- ..and install command line API methods smarter.

BUG=chromium:588893
R=dgozman@chromium.org

Review-Url: https://codereview.chromium.org/2784713002
Cr-Original-Commit-Position: refs/heads/master@{#44212}
Committed: https://chromium.googlesource.com/v8/v8/+/908cd38123df33ce293e4c8d25e407f7ca915f4c
Review-Url: https://codereview.chromium.org/2784713002
Cr-Commit-Position: refs/heads/master@{#44238}

src/inspector/inspected-context.cc

@@ -14,23 +14,6 @@
 
 namespace v8_inspector {
 
-namespace {
-
-void clearContext(const v8::WeakCallbackInfo<v8::Global<v8::Context>>& data) {
-  // Inspected context is created in V8InspectorImpl::contextCreated method
-  // and destroyed in V8InspectorImpl::contextDestroyed.
-  // Both methods takes valid v8::Local<v8::Context> handle to the same context,
-  // it means that context is created before InspectedContext constructor and is
-  // always destroyed after InspectedContext destructor therefore this callback
-  // should be never called.
-  // It's possible only if inspector client doesn't call contextDestroyed which
-  // is considered an error.
-  CHECK(false);
-  data.GetParameter()->Reset();
-}
-
-}  // namespace
-
 InspectedContext::InspectedContext(V8InspectorImpl* inspector,
                                    const V8ContextInfo& info, int contextId)
     : m_inspector(inspector),
@@ -44,27 +27,18 @@ InspectedContext::InspectedContext(V8InspectorImpl* inspector,
   v8::Isolate* isolate = m_inspector->isolate();
   info.context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex),
                                 v8::Int32::New(isolate, contextId));
-  m_context.SetWeak(&m_context, &clearContext,
-                    v8::WeakCallbackType::kParameter);
-
   v8::Local<v8::Object> global = info.context->Global();
   v8::Local<v8::Object> console =
       V8Console::createConsole(this, info.hasMemoryOnConsole);
   if (!global
            ->Set(info.context, toV8StringInternalized(isolate, "console"),
                  console)
-           .FromMaybe(false))
+           .FromMaybe(false)) {
     return;
-  m_console.Reset(isolate, console);
-  m_console.SetWeak();
+  }
 }
 
 InspectedContext::~InspectedContext() {
-  if (!m_console.IsEmpty()) {
-    v8::HandleScope scope(isolate());
-    V8Console::clearInspectedContextIfNeeded(context(),
-                                             m_console.Get(isolate()));
-  }
 }
 
 // static

src/inspector/inspected-context.h

@@ -53,7 +53,6 @@ class InspectedContext {
   const String16 m_auxData;
   bool m_reported;
   std::unique_ptr<InjectedScript> m_injectedScript;
-  v8::Global<v8::Object> m_console;
 
   DISALLOW_COPY_AND_ASSIGN(InspectedContext);
 };

src/inspector/v8-console-message.cc

@@ -353,15 +353,11 @@ ConsoleAPIType V8ConsoleMessage::type() const { return m_type; }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(
-    double timestamp, ConsoleAPIType type,
+    v8::Local<v8::Context> v8Context, int contextId, int groupId,
+    V8InspectorImpl* inspector, double timestamp, ConsoleAPIType type,
     const std::vector<v8::Local<v8::Value>>& arguments,
-    std::unique_ptr<V8StackTraceImpl> stackTrace,
-    InspectedContext* inspectedContext) {
-  v8::Isolate* isolate = inspectedContext->isolate();
-  int contextId = inspectedContext->contextId();
-  int contextGroupId = inspectedContext->contextGroupId();
-  V8InspectorImpl* inspector = inspectedContext->inspector();
-  v8::Local<v8::Context> context = inspectedContext->context();
+    std::unique_ptr<V8StackTraceImpl> stackTrace) {
+  v8::Isolate* isolate = v8Context->GetIsolate();
 
   std::unique_ptr<V8ConsoleMessage> message(
       new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, String16()));
@@ -380,7 +376,8 @@ std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(
         v8::debug::EstimatedValueSize(isolate, arguments.at(i));
   }
   if (arguments.size())
-    message->m_message = V8ValueStringBuilder::toString(arguments[0], context);
+    message->m_message =
+        V8ValueStringBuilder::toString(arguments[0], v8Context);
 
   v8::Isolate::MessageErrorLevel clientLevel = v8::Isolate::kMessageInfo;
   if (type == ConsoleAPIType::kDebug || type == ConsoleAPIType::kCount ||
@@ -397,7 +394,7 @@ std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(
 
   if (type != ConsoleAPIType::kClear) {
     inspector->client()->consoleAPIMessage(
-        contextGroupId, clientLevel, toStringView(message->m_message),
+        groupId, clientLevel, toStringView(message->m_message),
         toStringView(message->m_url), message->m_lineNumber,
         message->m_columnNumber, message->m_stackTrace.get());
   }
@@ -490,8 +487,37 @@ void V8ConsoleMessageStorage::clear() {
   m_messages.clear();
   m_estimatedSize = 0;
   if (V8InspectorSessionImpl* session =
-          m_inspector->sessionForContextGroup(m_contextGroupId))
+          m_inspector->sessionForContextGroup(m_contextGroupId)) {
     session->releaseObjectGroup("console");
+  }
+  m_data.clear();
+}
+
+bool V8ConsoleMessageStorage::shouldReportDeprecationMessage(
+    int contextId, const String16& method) {
+  std::set<String16>& reportedDeprecationMessages =
+      m_data[contextId].m_reportedDeprecationMessages;
+  auto it = reportedDeprecationMessages.find(method);
+  if (it != reportedDeprecationMessages.end()) return false;
+  reportedDeprecationMessages.insert(it, method);
+  return true;
+}
+
+int V8ConsoleMessageStorage::count(int contextId, const String16& id) {
+  return ++m_data[contextId].m_count[id];
+}
+
+void V8ConsoleMessageStorage::time(int contextId, const String16& id) {
+  m_data[contextId].m_time[id] = m_inspector->client()->currentTimeMS();
+}
+
+double V8ConsoleMessageStorage::timeEnd(int contextId, const String16& id) {
+  std::map<String16, double>& time = m_data[contextId].m_time;
+  auto it = time.find(id);
+  if (it == time.end()) return 0.0;
+  double elapsed = m_inspector->client()->currentTimeMS() - it->second;
+  time.erase(it);
+  return elapsed;
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId) {
@@ -500,6 +526,8 @@ void V8ConsoleMessageStorage::contextDestroyed(int contextId) {
     m_messages[i]->contextDestroyed(contextId);
     m_estimatedSize += m_messages[i]->estimatedSize();
   }
+  auto it = m_data.find(contextId);
+  if (it != m_data.end()) m_data.erase(contextId);
 }
 
 }  // namespace v8_inspector

src/inspector/v8-console-message.h

@@ -6,6 +6,8 @@
 #define V8_INSPECTOR_V8CONSOLEMESSAGE_H_
 
 #include <deque>
+#include <map>
+#include <set>
 #include "include/v8.h"
 #include "src/inspector/protocol/Console.h"
 #include "src/inspector/protocol/Forward.h"
@@ -44,9 +46,10 @@ class V8ConsoleMessage {
   ~V8ConsoleMessage();
 
   static std::unique_ptr<V8ConsoleMessage> createForConsoleAPI(
-      double timestamp, ConsoleAPIType,
+      v8::Local<v8::Context> v8Context, int contextId, int groupId,
+      V8InspectorImpl* inspector, double timestamp, ConsoleAPIType,
       const std::vector<v8::Local<v8::Value>>& arguments,
-      std::unique_ptr<V8StackTraceImpl>, InspectedContext*);
+      std::unique_ptr<V8StackTraceImpl>);
 
   static std::unique_ptr<V8ConsoleMessage> createForException(
       double timestamp, const String16& detailedMessage, const String16& url,
@@ -112,11 +115,23 @@ class V8ConsoleMessageStorage {
   void contextDestroyed(int contextId);
   void clear();
 
+  bool shouldReportDeprecationMessage(int contextId, const String16& method);
+  int count(int contextId, const String16& id);
+  void time(int contextId, const String16& id);
+  double timeEnd(int contextId, const String16& id);
+
  private:
   V8InspectorImpl* m_inspector;
   int m_contextGroupId;
   int m_estimatedSize = 0;
   std::deque<std::unique_ptr<V8ConsoleMessage>> m_messages;
+
+  struct PerContextData {
+    std::set<String16> m_reportedDeprecationMessages;
+    std::map<String16, int> m_count;
+    std::map<String16, double> m_time;
+  };
+  std::map<int, PerContextData> m_data;
 };
 
 }  // namespace v8_inspector

src/inspector/v8-console.h

@@ -19,8 +19,6 @@ class V8Console {
  public:
   static v8::Local<v8::Object> createConsole(InspectedContext*,
                                              bool hasMemoryAttribute);
-  static void clearInspectedContextIfNeeded(v8::Local<v8::Context>,
-                                            v8::Local<v8::Object> console);
   static v8::Local<v8::Object> createCommandLineAPI(InspectedContext*);
 
   class CommandLineAPIScope {

test/inspector/console/memory-setter-in-strict-mode-expected.txt

-Tests checks that console.memory property can be set in strict mode (crbug.com/468611).
-{
-    id : <messageId>
-    result : {
-        result : {
-            type : undefined
-        }
-    }
-}
\ No newline at end of file

test/inspector/console/memory-setter-in-strict-mode.js

-// Copyright 2016 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.
-
-InspectorTest.log("Tests checks that console.memory property can be set in strict mode (crbug.com/468611).")
-
-Protocol.Runtime.evaluate({ expression: "\"use strict\"\nconsole.memory = {};undefined" }).then(dumpResult);
-
-function dumpResult(result)
-{
-  InspectorTest.logMessage(result);
-  InspectorTest.completeTest();
-}

test/inspector/inspector-impl.cc

@@ -174,8 +174,10 @@ void InspectorClientImpl::connect(v8::Local<v8::Context> context) {
     sessions_[context_group_id] =
         inspector_->connect(context_group_id, channel_.get(), state);
     context->SetAlignedPointerInEmbedderData(kInspectorClientIndex, this);
-    inspector_->contextCreated(v8_inspector::V8ContextInfo(
-        context, context_group_id, v8_inspector::StringView()));
+    v8_inspector::V8ContextInfo info(context, context_group_id,
+                                     v8_inspector::StringView());
+    info.hasMemoryOnConsole = true;
+    inspector_->contextCreated(info);
   } else {
     for (const auto& it : states_) {
       int context_group_id = it.first;
@@ -185,8 +187,10 @@ void InspectorClientImpl::connect(v8::Local<v8::Context> context) {
       sessions_[context_group_id] =
           inspector_->connect(context_group_id, channel_.get(), state);
       context->SetAlignedPointerInEmbedderData(kInspectorClientIndex, this);
-      inspector_->contextCreated(v8_inspector::V8ContextInfo(
-          context, context_group_id, v8_inspector::StringView()));
+      v8_inspector::V8ContextInfo info(context, context_group_id,
+                                       v8_inspector::StringView());
+      info.hasMemoryOnConsole = true;
+      inspector_->contextCreated(info);
     }
   }
   states_.clear();
@@ -256,6 +260,17 @@ double InspectorClientImpl::currentTimeMS() {
   return v8::base::OS::TimeCurrentMillis();
 }
 
+void InspectorClientImpl::setMemoryInfoForTest(
+    v8::Local<v8::Value> memory_info) {
+  memory_info_.Reset(isolate_, memory_info);
+}
+
+v8::MaybeLocal<v8::Value> InspectorClientImpl::memoryInfo(
+    v8::Isolate* isolate, v8::Local<v8::Context>) {
+  if (memory_info_.IsEmpty()) return v8::MaybeLocal<v8::Value>();
+  return memory_info_.Get(isolate);
+}
+
 void InspectorClientImpl::runMessageLoopOnPause(int) {
   task_runner_->RunMessageLoop(true);
 }

test/inspector/inspector-impl.h

@@ -39,6 +39,7 @@ class InspectorClientImpl : public v8_inspector::V8InspectorClient {
   v8_inspector::V8InspectorSession* session(int context_group_id = 0);
 
   void setCurrentTimeMSForTest(double time);
+  void setMemoryInfoForTest(v8::Local<v8::Value> memory_info);
 
  private:
   // V8InspectorClient implementation.
@@ -46,6 +47,8 @@ class InspectorClientImpl : public v8_inspector::V8InspectorClient {
   v8::Local<v8::Context> ensureDefaultContextInGroup(
       int context_group_id) override;
   double currentTimeMS() override;
+  v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate* isolate,
+                                       v8::Local<v8::Context>) override;
   void runMessageLoopOnPause(int context_group_id) override;
   void quitMessageLoopOnPause() override;
 
@@ -65,6 +68,7 @@ class InspectorClientImpl : public v8_inspector::V8InspectorClient {
   std::map<int, std::unique_ptr<v8_inspector::StringBuffer>> states_;
 
   v8::Isolate* isolate_;
+  v8::Global<v8::Value> memory_info_;
 
   TaskRunner* task_runner_;
   FrontendChannel* frontend_channel_;

test/inspector/inspector-test.cc

@@ -57,6 +57,7 @@ class UtilsExtension : public v8::Extension {
                       "native function load();"
                       "native function compileAndRunWithOrigin();"
                       "native function setCurrentTimeMSForTest();"
+                      "native function setMemoryInfoForTest();"
                       "native function schedulePauseOnNextStatement();"
                       "native function cancelPauseOnNextStatement();"
                       "native function reconnect();"
@@ -107,6 +108,13 @@ class UtilsExtension : public v8::Extension {
                    .FromJust()) {
       return v8::FunctionTemplate::New(isolate,
                                        UtilsExtension::SetCurrentTimeMSForTest);
+    } else if (name->Equals(context, v8::String::NewFromUtf8(
+                                         isolate, "setMemoryInfoForTest",
+                                         v8::NewStringType::kNormal)
+                                         .ToLocalChecked())
+                   .FromJust()) {
+      return v8::FunctionTemplate::New(isolate,
+                                       UtilsExtension::SetMemoryInfoForTest);
     } else if (name->Equals(context,
                             v8::String::NewFromUtf8(
                                 isolate, "schedulePauseOnNextStatement",
@@ -266,6 +274,15 @@ class UtilsExtension : public v8::Extension {
         args[0].As<v8::Number>()->Value());
   }
 
+  static void SetMemoryInfoForTest(
+      const v8::FunctionCallbackInfo<v8::Value>& args) {
+    if (args.Length() != 1) {
+      fprintf(stderr, "Internal error: setMemoryInfoForTest(value).");
+      Exit();
+    }
+    inspector_client_->setMemoryInfoForTest(args[0]);
+  }
+
   static void SchedulePauseOnNextStatement(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsString()) {

test/inspector/protocol-test.js

@@ -49,6 +49,8 @@ var utils = {};
   this.setlocale = null;
   utils.setCurrentTimeMSForTest = setCurrentTimeMSForTest;
   this.setCurrentTimeMSForTest = null;
+  utils.setMemoryInfoForTest = setMemoryInfoForTest;
+  this.setMemoryInfoForTest = null;
   utils.schedulePauseOnNextStatement = schedulePauseOnNextStatement;
   this.schedulePauseOnNextStatement = null;
   utils.cancelPauseOnNextStatement = cancelPauseOnNextStatement;
@@ -75,6 +77,8 @@ InspectorTest.logMessage = function(originalMessage)
     for (var key in object) {
       if (nonStableFields.has(key))
         object[key] = `<${key}>`;
+      else if (typeof object[key] === "string" && object[key].match(/\d+:\d+:\d+:debug/))
+        object[key] = object[key].replace(/\d+/, '<scriptId>');
       else if (typeof object[key] === "object")
         objects.push(object[key]);
     }

test/inspector/runtime/command-line-api.js

+// Copyright 2017 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.
+
+InspectorTest.log('Checks command line API.');
+
+InspectorTest.runAsyncTestSuite([
+  async function testKeys() {
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({
+      expression: 'keys', includeCommandLineAPI: true}));
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({
+      expression: 'keys({a : 1})', includeCommandLineAPI: true, returnByValue: true}));
+
+    Protocol.Runtime.evaluate({expression: 'this.keys = keys', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({
+      expression: 'this.keys({a : 1})', returnByValue: true}));
+  },
+
+  async function testInspect() {
+    InspectorTest.log(await Protocol.Runtime.evaluate({expression: 'inspect', includeCommandLineAPI: true}));
+    await Protocol.Runtime.enable();
+    Protocol.Runtime.onInspectRequested(InspectorTest.logMessage);
+    await Protocol.Runtime.evaluate({expression: 'inspect({})', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({expression: 'inspect(239)', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({expression: 'inspect(-0)', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({expression: 'copy(\'hello\')', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: '$0', includeCommandLineAPI: true}));
+
+    Protocol.Runtime.evaluate({expression: 'this.inspect = inspect', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({expression: 'this.inspect({})'});
+
+    Protocol.Runtime.onInspectRequested(null);
+    await Protocol.Runtime.disable();
+  },
+
+  async function testEvaluationResult() {
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: '$_', includeCommandLineAPI: true}));
+    await Protocol.Runtime.evaluate({expression: '42', objectGroup: 'console', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: '$_', includeCommandLineAPI: true}));
+    await Protocol.Runtime.evaluate({expression: '239', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: '$_', includeCommandLineAPI: true}));
+    await Protocol.Runtime.evaluate({expression: '-0', objectGroup: 'console', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: '$_', includeCommandLineAPI: true}));
+    await Protocol.Runtime.evaluate({expression: '({})', objectGroup: 'console', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: '$_', includeCommandLineAPI: true, returnByValue: true}));
+  },
+
+  async function testDebug() {
+    InspectorTest.setupScriptMap();
+    await Protocol.Debugger.enable();
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'debug', includeCommandLineAPI: true}));
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'undebug', includeCommandLineAPI: true}));
+    await Protocol.Runtime.evaluate({expression: 'function foo() {}'});
+    await Protocol.Runtime.evaluate({expression: 'debug(foo)', includeCommandLineAPI: true});
+    Protocol.Runtime.evaluate({ expression: 'foo()'});
+    let message = await Protocol.Debugger.oncePaused();
+    InspectorTest.logCallFrames(message.params.callFrames);
+    InspectorTest.logMessage(message.params.hitBreakpoints);
+    await Protocol.Debugger.resume();
+    await Protocol.Runtime.evaluate({expression: 'undebug(foo)', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({ expression: 'foo()'});
+
+    Protocol.Runtime.evaluate({
+      expression: 'this.debug = debug; this.undebug = undebug;', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({expression: 'this.debug(foo)'});
+    Protocol.Runtime.evaluate({ expression: 'foo()'});
+    message = await Protocol.Debugger.oncePaused();
+    InspectorTest.logCallFrames(message.params.callFrames);
+    InspectorTest.logMessage(message.params.hitBreakpoints);
+    await Protocol.Debugger.resume();
+    await Protocol.Runtime.evaluate({expression: 'this.undebug(foo)'});
+    await Protocol.Runtime.evaluate({expression: 'foo()'});
+
+    await Protocol.Debugger.disable();
+  },
+
+  async function testMonitor() {
+    await Protocol.Debugger.enable();
+    await Protocol.Runtime.enable();
+    Protocol.Runtime.onConsoleAPICalled(message => InspectorTest.log(message.params.args[0].value));
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'monitor', includeCommandLineAPI: true}));
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'unmonitor', includeCommandLineAPI: true}));
+    await Protocol.Runtime.evaluate({expression: 'function foo() {}'});
+
+    await Protocol.Runtime.evaluate({expression: 'monitor(foo)', includeCommandLineAPI: true});
+    Protocol.Runtime.evaluate({ expression: 'foo(); console.log(\'after first call\')'});
+    await Protocol.Runtime.evaluate({expression: 'unmonitor(foo)', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({ expression: 'foo()'});
+
+    Protocol.Runtime.evaluate({
+      expression: 'console.log(\'store functions..\'); this.monitor = monitor; this.unmonitor = unmonitor;', includeCommandLineAPI: true});
+    await Protocol.Runtime.evaluate({expression: 'this.monitor(foo)'});
+    Protocol.Runtime.evaluate({ expression: 'foo(); console.log(\'after first call\')'});
+    await Protocol.Runtime.evaluate({expression: 'this.unmonitor(foo)'});
+    await Protocol.Runtime.evaluate({ expression: 'foo()'});
+
+    Protocol.Runtime.onConsoleAPICalled(null);
+    await Protocol.Debugger.disable();
+    await Protocol.Runtime.disable();
+  },
+
+  async function testProfile() {
+    await Protocol.Profiler.enable();
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'profile', includeCommandLineAPI: true}));
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'profileEnd', includeCommandLineAPI: true}));
+
+    Protocol.Runtime.evaluate({expression: 'profile(42)', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Profiler.onceConsoleProfileStarted());
+    Protocol.Runtime.evaluate({expression: 'profileEnd(42)', includeCommandLineAPI: true});
+    let message = await Protocol.Profiler.onceConsoleProfileFinished();
+    message.params.profile = '<profile>';
+    InspectorTest.logMessage(message);
+
+    Protocol.Runtime.evaluate({
+      expression: 'this.profile = profile; this.profileEnd = profileEnd;', includeCommandLineAPI: true});
+    Protocol.Runtime.evaluate({expression: 'this.profile(239)'});
+    InspectorTest.logMessage(await Protocol.Profiler.onceConsoleProfileStarted());
+    Protocol.Runtime.evaluate({expression: 'this.profileEnd(239)'});
+    message = await Protocol.Profiler.onceConsoleProfileFinished();
+    message.params.profile = '<profile>';
+    InspectorTest.logMessage(message);
+
+    await Protocol.Profiler.disable();
+  },
+
+  async function testDir() {
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'dir', includeCommandLineAPI: true}));
+
+    await Protocol.Runtime.enable();
+    Protocol.Runtime.evaluate({expression: 'dir({})', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    Protocol.Runtime.evaluate({expression: 'dir(42)', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+
+    Protocol.Runtime.evaluate({expression: 'this.dir = dir', includeCommandLineAPI: true});
+    Protocol.Runtime.evaluate({expression: 'this.dir({})'});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    await Protocol.Runtime.disable();
+  },
+
+  async function testDirXML() {
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'dirxml', includeCommandLineAPI: true}));
+
+    await Protocol.Runtime.enable();
+    Protocol.Runtime.evaluate({expression: 'dirxml({})', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    Protocol.Runtime.evaluate({expression: 'dirxml(42)', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    await Protocol.Runtime.disable();
+  },
+
+  async function testTable() {
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'table', includeCommandLineAPI: true}));
+
+    await Protocol.Runtime.enable();
+    Protocol.Runtime.evaluate({expression: 'table({})', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    Protocol.Runtime.evaluate({expression: 'table(42)', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    await Protocol.Runtime.disable();
+  },
+
+  async function testClear() {
+    InspectorTest.logMessage(await Protocol.Runtime.evaluate({expression: 'clear', includeCommandLineAPI: true}));
+
+    await Protocol.Runtime.enable();
+    Protocol.Runtime.evaluate({expression: 'clear()', includeCommandLineAPI: true});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+
+    Protocol.Runtime.evaluate({expression: 'this.clear = clear', includeCommandLineAPI: true});
+    Protocol.Runtime.evaluate({expression: 'this.clear()'});
+    InspectorTest.logMessage(await Protocol.Runtime.onceConsoleAPICalled());
+    await Protocol.Runtime.disable();
+  }
+]);

test/inspector/runtime/console-memory-expected.txt

+Checks console.memory
+
+Running test: testWithoutMemory
+{
+    id : <messageId>
+    result : {
+        result : {
+            type : undefined
+        }
+    }
+}
+
+Running test: testSetterInStrictMode
+{
+    id : <messageId>
+    result : {
+        result : {
+            type : undefined
+        }
+    }
+}
+
+Running test: testWithMemory
+{
+    id : <messageId>
+    result : {
+        result : {
+            description : 239
+            type : number
+            value : 239
+        }
+    }
+}
+
+Running test: testSetterDoesntOverride
+{
+    id : <messageId>
+    result : {
+        result : {
+            description : 42
+            type : number
+            value : 42
+        }
+    }
+}

test/inspector/runtime/console-memory.js

+// Copyright 2017 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.
+
+InspectorTest.log('Checks console.memory');
+
+InspectorTest.runAsyncTestSuite([
+  async function testWithoutMemory() {
+    InspectorTest.logMessage(
+      await Protocol.Runtime.evaluate({expression: 'console.memory'}));
+  },
+
+  async function testSetterInStrictMode() {
+    // crbug.com/468611
+    InspectorTest.logMessage(
+      await Protocol.Runtime.evaluate({
+        expression: '"use strict"\nconsole.memory = {};undefined' }));
+  },
+
+  async function testWithMemory() {
+    utils.setMemoryInfoForTest(239);
+    InspectorTest.logMessage(
+      await Protocol.Runtime.evaluate({expression: 'console.memory'}));
+  },
+
+  async function testSetterDoesntOverride() {
+    utils.setMemoryInfoForTest(42);
+    await Protocol.Runtime.evaluate({expression: 'console.memory = 0'});
+    InspectorTest.logMessage(
+      await Protocol.Runtime.evaluate({expression: 'console.memory'}));
+  }
+]);