1 // Copyright 2016 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "src/inspector/v8-console.h"
6 
7 #include "src/base/macros.h"
8 #include "src/inspector/injected-script.h"
9 #include "src/inspector/inspected-context.h"
10 #include "src/inspector/string-util.h"
11 #include "src/inspector/v8-console-message.h"
12 #include "src/inspector/v8-debugger-agent-impl.h"
13 #include "src/inspector/v8-inspector-impl.h"
14 #include "src/inspector/v8-inspector-session-impl.h"
15 #include "src/inspector/v8-profiler-agent-impl.h"
16 #include "src/inspector/v8-runtime-agent-impl.h"
17 #include "src/inspector/v8-stack-trace-impl.h"
18 #include "src/inspector/v8-value-copier.h"
19 
20 #include "include/v8-inspector.h"
21 
22 namespace v8_inspector {
23 
24 namespace {
25 
inspectedContextPrivateKey(v8::Isolate * isolate)26 v8::Local<v8::Private> inspectedContextPrivateKey(v8::Isolate* isolate) {
27   return v8::Private::ForApi(
28       isolate, toV8StringInternalized(isolate, "V8Console#InspectedContext"));
29 }
30 
31 class ConsoleHelper {
32  public:
ConsoleHelper(const v8::FunctionCallbackInfo<v8::Value> & info)33   explicit ConsoleHelper(const v8::FunctionCallbackInfo<v8::Value>& info)
34       : m_info(info),
35         m_isolate(info.GetIsolate()),
36         m_context(info.GetIsolate()->GetCurrentContext()),
37         m_inspectedContext(nullptr),
38         m_inspectorClient(nullptr) {}
39 
ensureConsole()40   v8::Local<v8::Object> ensureConsole() {
41     if (m_console.IsEmpty()) {
42       DCHECK(!m_info.Data().IsEmpty());
43       DCHECK(!m_info.Data()->IsUndefined());
44       m_console = m_info.Data().As<v8::Object>();
45     }
46     return m_console;
47   }
48 
ensureInspectedContext()49   InspectedContext* ensureInspectedContext() {
50     if (m_inspectedContext) return m_inspectedContext;
51     v8::Local<v8::Object> console = ensureConsole();
52 
53     v8::Local<v8::Private> key = inspectedContextPrivateKey(m_isolate);
54     v8::Local<v8::Value> inspectedContextValue;
55     if (!console->GetPrivate(m_context, key).ToLocal(&inspectedContextValue))
56       return nullptr;
57     DCHECK(inspectedContextValue->IsExternal());
58     m_inspectedContext = static_cast<InspectedContext*>(
59         inspectedContextValue.As<v8::External>()->Value());
60     return m_inspectedContext;
61   }
62 
ensureDebuggerClient()63   V8InspectorClient* ensureDebuggerClient() {
64     if (m_inspectorClient) return m_inspectorClient;
65     InspectedContext* inspectedContext = ensureInspectedContext();
66     if (!inspectedContext) return nullptr;
67     m_inspectorClient = inspectedContext->inspector()->client();
68     return m_inspectorClient;
69   }
70 
reportCall(ConsoleAPIType type)71   void reportCall(ConsoleAPIType type) {
72     if (!m_info.Length()) return;
73     std::vector<v8::Local<v8::Value>> arguments;
74     for (int i = 0; i < m_info.Length(); ++i) arguments.push_back(m_info[i]);
75     reportCall(type, arguments);
76   }
77 
reportCallWithDefaultArgument(ConsoleAPIType type,const String16 & message)78   void reportCallWithDefaultArgument(ConsoleAPIType type,
79                                      const String16& message) {
80     std::vector<v8::Local<v8::Value>> arguments;
81     for (int i = 0; i < m_info.Length(); ++i) arguments.push_back(m_info[i]);
82     if (!m_info.Length()) arguments.push_back(toV8String(m_isolate, message));
83     reportCall(type, arguments);
84   }
85 
reportCallWithArgument(ConsoleAPIType type,const String16 & message)86   void reportCallWithArgument(ConsoleAPIType type, const String16& message) {
87     std::vector<v8::Local<v8::Value>> arguments(1,
88                                                 toV8String(m_isolate, message));
89     reportCall(type, arguments);
90   }
91 
reportCall(ConsoleAPIType type,const std::vector<v8::Local<v8::Value>> & arguments)92   void reportCall(ConsoleAPIType type,
93                   const std::vector<v8::Local<v8::Value>>& arguments) {
94     InspectedContext* inspectedContext = ensureInspectedContext();
95     if (!inspectedContext) return;
96     int contextGroupId = inspectedContext->contextGroupId();
97     V8InspectorImpl* inspector = inspectedContext->inspector();
98     std::unique_ptr<V8ConsoleMessage> message =
99         V8ConsoleMessage::createForConsoleAPI(
100             inspector->client()->currentTimeMS(), type, arguments,
101             inspector->debugger()->captureStackTrace(false), inspectedContext);
102     inspector->ensureConsoleMessageStorage(contextGroupId)
103         ->addMessage(std::move(message));
104   }
105 
reportDeprecatedCall(const char * id,const String16 & message)106   void reportDeprecatedCall(const char* id, const String16& message) {
107     if (checkAndSetPrivateFlagOnConsole(id, false)) return;
108     std::vector<v8::Local<v8::Value>> arguments(1,
109                                                 toV8String(m_isolate, message));
110     reportCall(ConsoleAPIType::kWarning, arguments);
111   }
112 
firstArgToBoolean(bool defaultValue)113   bool firstArgToBoolean(bool defaultValue) {
114     if (m_info.Length() < 1) return defaultValue;
115     if (m_info[0]->IsBoolean()) return m_info[0].As<v8::Boolean>()->Value();
116     return m_info[0]->BooleanValue(m_context).FromMaybe(defaultValue);
117   }
118 
firstArgToString(const String16 & defaultValue)119   String16 firstArgToString(const String16& defaultValue) {
120     if (m_info.Length() < 1) return defaultValue;
121     v8::Local<v8::String> titleValue;
122     if (m_info[0]->IsObject()) {
123       if (!m_info[0].As<v8::Object>()->ObjectProtoToString(m_context).ToLocal(
124               &titleValue))
125         return defaultValue;
126     } else {
127       if (!m_info[0]->ToString(m_context).ToLocal(&titleValue))
128         return defaultValue;
129     }
130     return toProtocolString(titleValue);
131   }
132 
firstArgAsObject()133   v8::MaybeLocal<v8::Object> firstArgAsObject() {
134     if (m_info.Length() < 1 || !m_info[0]->IsObject())
135       return v8::MaybeLocal<v8::Object>();
136     return m_info[0].As<v8::Object>();
137   }
138 
firstArgAsFunction()139   v8::MaybeLocal<v8::Function> firstArgAsFunction() {
140     if (m_info.Length() < 1 || !m_info[0]->IsFunction())
141       return v8::MaybeLocal<v8::Function>();
142     v8::Local<v8::Function> func = m_info[0].As<v8::Function>();
143     while (func->GetBoundFunction()->IsFunction())
144       func = func->GetBoundFunction().As<v8::Function>();
145     return func;
146   }
147 
privateMap(const char * name)148   v8::MaybeLocal<v8::Map> privateMap(const char* name) {
149     v8::Local<v8::Object> console = ensureConsole();
150     v8::Local<v8::Private> privateKey =
151         v8::Private::ForApi(m_isolate, toV8StringInternalized(m_isolate, name));
152     v8::Local<v8::Value> mapValue;
153     if (!console->GetPrivate(m_context, privateKey).ToLocal(&mapValue))
154       return v8::MaybeLocal<v8::Map>();
155     if (mapValue->IsUndefined()) {
156       v8::Local<v8::Map> map = v8::Map::New(m_isolate);
157       if (!console->SetPrivate(m_context, privateKey, map).FromMaybe(false))
158         return v8::MaybeLocal<v8::Map>();
159       return map;
160     }
161     return mapValue->IsMap() ? mapValue.As<v8::Map>()
162                              : v8::MaybeLocal<v8::Map>();
163   }
164 
getIntFromMap(v8::Local<v8::Map> map,const String16 & key,int32_t defaultValue)165   int32_t getIntFromMap(v8::Local<v8::Map> map, const String16& key,
166                         int32_t defaultValue) {
167     v8::Local<v8::String> v8Key = toV8String(m_isolate, key);
168     if (!map->Has(m_context, v8Key).FromMaybe(false)) return defaultValue;
169     v8::Local<v8::Value> intValue;
170     if (!map->Get(m_context, v8Key).ToLocal(&intValue)) return defaultValue;
171     return static_cast<int32_t>(intValue.As<v8::Integer>()->Value());
172   }
173 
setIntOnMap(v8::Local<v8::Map> map,const String16 & key,int32_t value)174   void setIntOnMap(v8::Local<v8::Map> map, const String16& key, int32_t value) {
175     v8::Local<v8::String> v8Key = toV8String(m_isolate, key);
176     if (!map->Set(m_context, v8Key, v8::Integer::New(m_isolate, value))
177              .ToLocal(&map))
178       return;
179   }
180 
getDoubleFromMap(v8::Local<v8::Map> map,const String16 & key,double defaultValue)181   double getDoubleFromMap(v8::Local<v8::Map> map, const String16& key,
182                           double defaultValue) {
183     v8::Local<v8::String> v8Key = toV8String(m_isolate, key);
184     if (!map->Has(m_context, v8Key).FromMaybe(false)) return defaultValue;
185     v8::Local<v8::Value> intValue;
186     if (!map->Get(m_context, v8Key).ToLocal(&intValue)) return defaultValue;
187     return intValue.As<v8::Number>()->Value();
188   }
189 
setDoubleOnMap(v8::Local<v8::Map> map,const String16 & key,double value)190   void setDoubleOnMap(v8::Local<v8::Map> map, const String16& key,
191                       double value) {
192     v8::Local<v8::String> v8Key = toV8String(m_isolate, key);
193     if (!map->Set(m_context, v8Key, v8::Number::New(m_isolate, value))
194              .ToLocal(&map))
195       return;
196   }
197 
profilerAgent()198   V8ProfilerAgentImpl* profilerAgent() {
199     if (V8InspectorSessionImpl* session = currentSession()) {
200       if (session && session->profilerAgent()->enabled())
201         return session->profilerAgent();
202     }
203     return nullptr;
204   }
205 
debuggerAgent()206   V8DebuggerAgentImpl* debuggerAgent() {
207     if (V8InspectorSessionImpl* session = currentSession()) {
208       if (session && session->debuggerAgent()->enabled())
209         return session->debuggerAgent();
210     }
211     return nullptr;
212   }
213 
currentSession()214   V8InspectorSessionImpl* currentSession() {
215     InspectedContext* inspectedContext = ensureInspectedContext();
216     if (!inspectedContext) return nullptr;
217     return inspectedContext->inspector()->sessionForContextGroup(
218         inspectedContext->contextGroupId());
219   }
220 
221  private:
222   const v8::FunctionCallbackInfo<v8::Value>& m_info;
223   v8::Isolate* m_isolate;
224   v8::Local<v8::Context> m_context;
225   v8::Local<v8::Object> m_console;
226   InspectedContext* m_inspectedContext;
227   V8InspectorClient* m_inspectorClient;
228 
checkAndSetPrivateFlagOnConsole(const char * name,bool defaultValue)229   bool checkAndSetPrivateFlagOnConsole(const char* name, bool defaultValue) {
230     v8::Local<v8::Object> console = ensureConsole();
231     v8::Local<v8::Private> key =
232         v8::Private::ForApi(m_isolate, toV8StringInternalized(m_isolate, name));
233     v8::Local<v8::Value> flagValue;
234     if (!console->GetPrivate(m_context, key).ToLocal(&flagValue))
235       return defaultValue;
236     DCHECK(flagValue->IsUndefined() || flagValue->IsBoolean());
237     if (flagValue->IsBoolean()) {
238       DCHECK(flagValue.As<v8::Boolean>()->Value());
239       return true;
240     }
241     if (!console->SetPrivate(m_context, key, v8::True(m_isolate))
242              .FromMaybe(false))
243       return defaultValue;
244     return false;
245   }
246 
247   DISALLOW_COPY_AND_ASSIGN(ConsoleHelper);
248 };
249 
returnDataCallback(const v8::FunctionCallbackInfo<v8::Value> & info)250 void returnDataCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
251   info.GetReturnValue().Set(info.Data());
252 }
253 
createBoundFunctionProperty(v8::Local<v8::Context> context,v8::Local<v8::Object> console,const char * name,v8::FunctionCallback callback,const char * description=nullptr)254 void createBoundFunctionProperty(v8::Local<v8::Context> context,
255                                  v8::Local<v8::Object> console,
256                                  const char* name,
257                                  v8::FunctionCallback callback,
258                                  const char* description = nullptr) {
259   v8::Local<v8::String> funcName =
260       toV8StringInternalized(context->GetIsolate(), name);
261   v8::Local<v8::Function> func;
262   if (!v8::Function::New(context, callback, console, 0,
263                          v8::ConstructorBehavior::kThrow)
264            .ToLocal(&func))
265     return;
266   func->SetName(funcName);
267   if (description) {
268     v8::Local<v8::String> returnValue =
269         toV8String(context->GetIsolate(), description);
270     v8::Local<v8::Function> toStringFunction;
271     if (v8::Function::New(context, returnDataCallback, returnValue, 0,
272                           v8::ConstructorBehavior::kThrow)
273             .ToLocal(&toStringFunction))
274       createDataProperty(context, func, toV8StringInternalized(
275                                             context->GetIsolate(), "toString"),
276                          toStringFunction);
277   }
278   createDataProperty(context, console, funcName, func);
279 }
280 
281 }  // namespace
282 
debugCallback(const v8::FunctionCallbackInfo<v8::Value> & info)283 void V8Console::debugCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
284   ConsoleHelper(info).reportCall(ConsoleAPIType::kDebug);
285 }
286 
errorCallback(const v8::FunctionCallbackInfo<v8::Value> & info)287 void V8Console::errorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
288   ConsoleHelper(info).reportCall(ConsoleAPIType::kError);
289 }
290 
infoCallback(const v8::FunctionCallbackInfo<v8::Value> & info)291 void V8Console::infoCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
292   ConsoleHelper(info).reportCall(ConsoleAPIType::kInfo);
293 }
294 
logCallback(const v8::FunctionCallbackInfo<v8::Value> & info)295 void V8Console::logCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
296   ConsoleHelper(info).reportCall(ConsoleAPIType::kLog);
297 }
298 
warnCallback(const v8::FunctionCallbackInfo<v8::Value> & info)299 void V8Console::warnCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
300   ConsoleHelper(info).reportCall(ConsoleAPIType::kWarning);
301 }
302 
dirCallback(const v8::FunctionCallbackInfo<v8::Value> & info)303 void V8Console::dirCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
304   ConsoleHelper(info).reportCall(ConsoleAPIType::kDir);
305 }
306 
dirxmlCallback(const v8::FunctionCallbackInfo<v8::Value> & info)307 void V8Console::dirxmlCallback(
308     const v8::FunctionCallbackInfo<v8::Value>& info) {
309   ConsoleHelper(info).reportCall(ConsoleAPIType::kDirXML);
310 }
311 
tableCallback(const v8::FunctionCallbackInfo<v8::Value> & info)312 void V8Console::tableCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
313   ConsoleHelper(info).reportCall(ConsoleAPIType::kTable);
314 }
315 
traceCallback(const v8::FunctionCallbackInfo<v8::Value> & info)316 void V8Console::traceCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
317   ConsoleHelper(info).reportCallWithDefaultArgument(ConsoleAPIType::kTrace,
318                                                     String16("console.trace"));
319 }
320 
groupCallback(const v8::FunctionCallbackInfo<v8::Value> & info)321 void V8Console::groupCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
322   ConsoleHelper(info).reportCallWithDefaultArgument(ConsoleAPIType::kStartGroup,
323                                                     String16("console.group"));
324 }
325 
groupCollapsedCallback(const v8::FunctionCallbackInfo<v8::Value> & info)326 void V8Console::groupCollapsedCallback(
327     const v8::FunctionCallbackInfo<v8::Value>& info) {
328   ConsoleHelper(info).reportCallWithDefaultArgument(
329       ConsoleAPIType::kStartGroupCollapsed, String16("console.groupCollapsed"));
330 }
331 
groupEndCallback(const v8::FunctionCallbackInfo<v8::Value> & info)332 void V8Console::groupEndCallback(
333     const v8::FunctionCallbackInfo<v8::Value>& info) {
334   ConsoleHelper(info).reportCallWithDefaultArgument(
335       ConsoleAPIType::kEndGroup, String16("console.groupEnd"));
336 }
337 
clearCallback(const v8::FunctionCallbackInfo<v8::Value> & info)338 void V8Console::clearCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
339   ConsoleHelper(info).reportCallWithDefaultArgument(ConsoleAPIType::kClear,
340                                                     String16("console.clear"));
341 }
342 
countCallback(const v8::FunctionCallbackInfo<v8::Value> & info)343 void V8Console::countCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
344   ConsoleHelper helper(info);
345 
346   String16 title = helper.firstArgToString(String16());
347   String16 identifier;
348   if (title.isEmpty()) {
349     std::unique_ptr<V8StackTraceImpl> stackTrace =
350         V8StackTraceImpl::capture(nullptr, 0, 1);
351     if (stackTrace && !stackTrace->isEmpty()) {
352       identifier = toString16(stackTrace->topSourceURL()) + ":" +
353                    String16::fromInteger(stackTrace->topLineNumber());
354     }
355   } else {
356     identifier = title + "@";
357   }
358 
359   v8::Local<v8::Map> countMap;
360   if (!helper.privateMap("V8Console#countMap").ToLocal(&countMap)) return;
361   int32_t count = helper.getIntFromMap(countMap, identifier, 0) + 1;
362   helper.setIntOnMap(countMap, identifier, count);
363   helper.reportCallWithArgument(ConsoleAPIType::kCount,
364                                 title + ": " + String16::fromInteger(count));
365 }
366 
assertCallback(const v8::FunctionCallbackInfo<v8::Value> & info)367 void V8Console::assertCallback(
368     const v8::FunctionCallbackInfo<v8::Value>& info) {
369   ConsoleHelper helper(info);
370   if (helper.firstArgToBoolean(false)) return;
371 
372   std::vector<v8::Local<v8::Value>> arguments;
373   for (int i = 1; i < info.Length(); ++i) arguments.push_back(info[i]);
374   if (info.Length() < 2)
375     arguments.push_back(
376         toV8String(info.GetIsolate(), String16("console.assert")));
377   helper.reportCall(ConsoleAPIType::kAssert, arguments);
378 
379   if (V8DebuggerAgentImpl* debuggerAgent = helper.debuggerAgent())
380     debuggerAgent->breakProgramOnException(
381         protocol::Debugger::Paused::ReasonEnum::Assert, nullptr);
382 }
383 
markTimelineCallback(const v8::FunctionCallbackInfo<v8::Value> & info)384 void V8Console::markTimelineCallback(
385     const v8::FunctionCallbackInfo<v8::Value>& info) {
386   ConsoleHelper(info).reportDeprecatedCall("V8Console#markTimelineDeprecated",
387                                            "'console.markTimeline' is "
388                                            "deprecated. Please use "
389                                            "'console.timeStamp' instead.");
390   timeStampCallback(info);
391 }
392 
profileCallback(const v8::FunctionCallbackInfo<v8::Value> & info)393 void V8Console::profileCallback(
394     const v8::FunctionCallbackInfo<v8::Value>& info) {
395   ConsoleHelper helper(info);
396   if (V8ProfilerAgentImpl* profilerAgent = helper.profilerAgent())
397     profilerAgent->consoleProfile(helper.firstArgToString(String16()));
398 }
399 
profileEndCallback(const v8::FunctionCallbackInfo<v8::Value> & info)400 void V8Console::profileEndCallback(
401     const v8::FunctionCallbackInfo<v8::Value>& info) {
402   ConsoleHelper helper(info);
403   if (V8ProfilerAgentImpl* profilerAgent = helper.profilerAgent())
404     profilerAgent->consoleProfileEnd(helper.firstArgToString(String16()));
405 }
406 
timeFunction(const v8::FunctionCallbackInfo<v8::Value> & info,bool timelinePrefix)407 static void timeFunction(const v8::FunctionCallbackInfo<v8::Value>& info,
408                          bool timelinePrefix) {
409   ConsoleHelper helper(info);
410   if (V8InspectorClient* client = helper.ensureDebuggerClient()) {
411     String16 protocolTitle = helper.firstArgToString("default");
412     if (timelinePrefix) protocolTitle = "Timeline '" + protocolTitle + "'";
413     client->consoleTime(toStringView(protocolTitle));
414 
415     v8::Local<v8::Map> timeMap;
416     if (!helper.privateMap("V8Console#timeMap").ToLocal(&timeMap)) return;
417     helper.setDoubleOnMap(timeMap, protocolTitle, client->currentTimeMS());
418   }
419 }
420 
timeEndFunction(const v8::FunctionCallbackInfo<v8::Value> & info,bool timelinePrefix)421 static void timeEndFunction(const v8::FunctionCallbackInfo<v8::Value>& info,
422                             bool timelinePrefix) {
423   ConsoleHelper helper(info);
424   if (V8InspectorClient* client = helper.ensureDebuggerClient()) {
425     String16 protocolTitle = helper.firstArgToString("default");
426     if (timelinePrefix) protocolTitle = "Timeline '" + protocolTitle + "'";
427     client->consoleTimeEnd(toStringView(protocolTitle));
428 
429     v8::Local<v8::Map> timeMap;
430     if (!helper.privateMap("V8Console#timeMap").ToLocal(&timeMap)) return;
431     double elapsed = client->currentTimeMS() -
432                      helper.getDoubleFromMap(timeMap, protocolTitle, 0.0);
433     String16 message =
434         protocolTitle + ": " + String16::fromDouble(elapsed, 3) + "ms";
435     helper.reportCallWithArgument(ConsoleAPIType::kTimeEnd, message);
436   }
437 }
438 
timelineCallback(const v8::FunctionCallbackInfo<v8::Value> & info)439 void V8Console::timelineCallback(
440     const v8::FunctionCallbackInfo<v8::Value>& info) {
441   ConsoleHelper(info).reportDeprecatedCall(
442       "V8Console#timeline",
443       "'console.timeline' is deprecated. Please use 'console.time' instead.");
444   timeFunction(info, true);
445 }
446 
timelineEndCallback(const v8::FunctionCallbackInfo<v8::Value> & info)447 void V8Console::timelineEndCallback(
448     const v8::FunctionCallbackInfo<v8::Value>& info) {
449   ConsoleHelper(info).reportDeprecatedCall("V8Console#timelineEnd",
450                                            "'console.timelineEnd' is "
451                                            "deprecated. Please use "
452                                            "'console.timeEnd' instead.");
453   timeEndFunction(info, true);
454 }
455 
timeCallback(const v8::FunctionCallbackInfo<v8::Value> & info)456 void V8Console::timeCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
457   timeFunction(info, false);
458 }
459 
timeEndCallback(const v8::FunctionCallbackInfo<v8::Value> & info)460 void V8Console::timeEndCallback(
461     const v8::FunctionCallbackInfo<v8::Value>& info) {
462   timeEndFunction(info, false);
463 }
464 
timeStampCallback(const v8::FunctionCallbackInfo<v8::Value> & info)465 void V8Console::timeStampCallback(
466     const v8::FunctionCallbackInfo<v8::Value>& info) {
467   ConsoleHelper helper(info);
468   if (V8InspectorClient* client = helper.ensureDebuggerClient()) {
469     String16 title = helper.firstArgToString(String16());
470     client->consoleTimeStamp(toStringView(title));
471   }
472 }
473 
memoryGetterCallback(const v8::FunctionCallbackInfo<v8::Value> & info)474 void V8Console::memoryGetterCallback(
475     const v8::FunctionCallbackInfo<v8::Value>& info) {
476   if (V8InspectorClient* client = ConsoleHelper(info).ensureDebuggerClient()) {
477     v8::Local<v8::Value> memoryValue;
478     if (!client
479              ->memoryInfo(info.GetIsolate(),
480                           info.GetIsolate()->GetCurrentContext())
481              .ToLocal(&memoryValue))
482       return;
483     info.GetReturnValue().Set(memoryValue);
484   }
485 }
486 
memorySetterCallback(const v8::FunctionCallbackInfo<v8::Value> & info)487 void V8Console::memorySetterCallback(
488     const v8::FunctionCallbackInfo<v8::Value>& info) {
489   // We can't make the attribute readonly as it breaks existing code that relies
490   // on being able to assign to console.memory in strict mode. Instead, the
491   // setter just ignores the passed value.  http://crbug.com/468611
492 }
493 
keysCallback(const v8::FunctionCallbackInfo<v8::Value> & info)494 void V8Console::keysCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
495   v8::Isolate* isolate = info.GetIsolate();
496   info.GetReturnValue().Set(v8::Array::New(isolate));
497 
498   ConsoleHelper helper(info);
499   v8::Local<v8::Object> obj;
500   if (!helper.firstArgAsObject().ToLocal(&obj)) return;
501   v8::Local<v8::Array> names;
502   if (!obj->GetOwnPropertyNames(isolate->GetCurrentContext()).ToLocal(&names))
503     return;
504   info.GetReturnValue().Set(names);
505 }
506 
valuesCallback(const v8::FunctionCallbackInfo<v8::Value> & info)507 void V8Console::valuesCallback(
508     const v8::FunctionCallbackInfo<v8::Value>& info) {
509   v8::Isolate* isolate = info.GetIsolate();
510   info.GetReturnValue().Set(v8::Array::New(isolate));
511 
512   ConsoleHelper helper(info);
513   v8::Local<v8::Object> obj;
514   if (!helper.firstArgAsObject().ToLocal(&obj)) return;
515   v8::Local<v8::Array> names;
516   v8::Local<v8::Context> context = isolate->GetCurrentContext();
517   if (!obj->GetOwnPropertyNames(context).ToLocal(&names)) return;
518   v8::Local<v8::Array> values = v8::Array::New(isolate, names->Length());
519   for (uint32_t i = 0; i < names->Length(); ++i) {
520     v8::Local<v8::Value> key;
521     if (!names->Get(context, i).ToLocal(&key)) continue;
522     v8::Local<v8::Value> value;
523     if (!obj->Get(context, key).ToLocal(&value)) continue;
524     createDataProperty(context, values, i, value);
525   }
526   info.GetReturnValue().Set(values);
527 }
528 
setFunctionBreakpoint(ConsoleHelper & helper,v8::Local<v8::Function> function,V8DebuggerAgentImpl::BreakpointSource source,const String16 & condition,bool enable)529 static void setFunctionBreakpoint(ConsoleHelper& helper,
530                                   v8::Local<v8::Function> function,
531                                   V8DebuggerAgentImpl::BreakpointSource source,
532                                   const String16& condition, bool enable) {
533   V8DebuggerAgentImpl* debuggerAgent = helper.debuggerAgent();
534   if (!debuggerAgent) return;
535   String16 scriptId = String16::fromInteger(function->ScriptId());
536   int lineNumber = function->GetScriptLineNumber();
537   int columnNumber = function->GetScriptColumnNumber();
538   if (lineNumber == v8::Function::kLineOffsetNotFound ||
539       columnNumber == v8::Function::kLineOffsetNotFound)
540     return;
541   if (enable)
542     debuggerAgent->setBreakpointAt(scriptId, lineNumber, columnNumber, source,
543                                    condition);
544   else
545     debuggerAgent->removeBreakpointAt(scriptId, lineNumber, columnNumber,
546                                       source);
547 }
548 
debugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value> & info)549 void V8Console::debugFunctionCallback(
550     const v8::FunctionCallbackInfo<v8::Value>& info) {
551   ConsoleHelper helper(info);
552   v8::Local<v8::Function> function;
553   if (!helper.firstArgAsFunction().ToLocal(&function)) return;
554   setFunctionBreakpoint(helper, function,
555                         V8DebuggerAgentImpl::DebugCommandBreakpointSource,
556                         String16(), true);
557 }
558 
undebugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value> & info)559 void V8Console::undebugFunctionCallback(
560     const v8::FunctionCallbackInfo<v8::Value>& info) {
561   ConsoleHelper helper(info);
562   v8::Local<v8::Function> function;
563   if (!helper.firstArgAsFunction().ToLocal(&function)) return;
564   setFunctionBreakpoint(helper, function,
565                         V8DebuggerAgentImpl::DebugCommandBreakpointSource,
566                         String16(), false);
567 }
568 
monitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value> & info)569 void V8Console::monitorFunctionCallback(
570     const v8::FunctionCallbackInfo<v8::Value>& info) {
571   ConsoleHelper helper(info);
572   v8::Local<v8::Function> function;
573   if (!helper.firstArgAsFunction().ToLocal(&function)) return;
574   v8::Local<v8::Value> name = function->GetName();
575   if (!name->IsString() || !v8::Local<v8::String>::Cast(name)->Length())
576     name = function->GetInferredName();
577   String16 functionName = toProtocolStringWithTypeCheck(name);
578   String16Builder builder;
579   builder.append("console.log(\"function ");
580   if (functionName.isEmpty())
581     builder.append("(anonymous function)");
582   else
583     builder.append(functionName);
584   builder.append(
585       " called\" + (arguments.length > 0 ? \" with arguments: \" + "
586       "Array.prototype.join.call(arguments, \", \") : \"\")) && false");
587   setFunctionBreakpoint(helper, function,
588                         V8DebuggerAgentImpl::MonitorCommandBreakpointSource,
589                         builder.toString(), true);
590 }
591 
unmonitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value> & info)592 void V8Console::unmonitorFunctionCallback(
593     const v8::FunctionCallbackInfo<v8::Value>& info) {
594   ConsoleHelper helper(info);
595   v8::Local<v8::Function> function;
596   if (!helper.firstArgAsFunction().ToLocal(&function)) return;
597   setFunctionBreakpoint(helper, function,
598                         V8DebuggerAgentImpl::MonitorCommandBreakpointSource,
599                         String16(), false);
600 }
601 
lastEvaluationResultCallback(const v8::FunctionCallbackInfo<v8::Value> & info)602 void V8Console::lastEvaluationResultCallback(
603     const v8::FunctionCallbackInfo<v8::Value>& info) {
604   ConsoleHelper helper(info);
605   InspectedContext* context = helper.ensureInspectedContext();
606   if (!context) return;
607   if (InjectedScript* injectedScript = context->getInjectedScript())
608     info.GetReturnValue().Set(injectedScript->lastEvaluationResult());
609 }
610 
inspectImpl(const v8::FunctionCallbackInfo<v8::Value> & info,bool copyToClipboard)611 static void inspectImpl(const v8::FunctionCallbackInfo<v8::Value>& info,
612                         bool copyToClipboard) {
613   if (info.Length() < 1) return;
614   if (!copyToClipboard) info.GetReturnValue().Set(info[0]);
615 
616   ConsoleHelper helper(info);
617   InspectedContext* context = helper.ensureInspectedContext();
618   if (!context) return;
619   InjectedScript* injectedScript = context->getInjectedScript();
620   if (!injectedScript) return;
621   std::unique_ptr<protocol::Runtime::RemoteObject> wrappedObject;
622   protocol::Response response =
623       injectedScript->wrapObject(info[0], "", false /** forceValueType */,
624                                  false /** generatePreview */, &wrappedObject);
625   if (!response.isSuccess()) return;
626 
627   std::unique_ptr<protocol::DictionaryValue> hints =
628       protocol::DictionaryValue::create();
629   if (copyToClipboard) hints->setBoolean("copyToClipboard", true);
630   if (V8InspectorSessionImpl* session = helper.currentSession())
631     session->runtimeAgent()->inspect(std::move(wrappedObject),
632                                      std::move(hints));
633 }
634 
inspectCallback(const v8::FunctionCallbackInfo<v8::Value> & info)635 void V8Console::inspectCallback(
636     const v8::FunctionCallbackInfo<v8::Value>& info) {
637   inspectImpl(info, false);
638 }
639 
copyCallback(const v8::FunctionCallbackInfo<v8::Value> & info)640 void V8Console::copyCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
641   inspectImpl(info, true);
642 }
643 
inspectedObject(const v8::FunctionCallbackInfo<v8::Value> & info,unsigned num)644 void V8Console::inspectedObject(const v8::FunctionCallbackInfo<v8::Value>& info,
645                                 unsigned num) {
646   DCHECK(num < V8InspectorSessionImpl::kInspectedObjectBufferSize);
647   ConsoleHelper helper(info);
648   if (V8InspectorSessionImpl* session = helper.currentSession()) {
649     V8InspectorSession::Inspectable* object = session->inspectedObject(num);
650     v8::Isolate* isolate = info.GetIsolate();
651     if (object)
652       info.GetReturnValue().Set(object->get(isolate->GetCurrentContext()));
653     else
654       info.GetReturnValue().Set(v8::Undefined(isolate));
655   }
656 }
657 
createConsole(InspectedContext * inspectedContext,bool hasMemoryAttribute)658 v8::Local<v8::Object> V8Console::createConsole(
659     InspectedContext* inspectedContext, bool hasMemoryAttribute) {
660   v8::Local<v8::Context> context = inspectedContext->context();
661   v8::Context::Scope contextScope(context);
662   v8::Isolate* isolate = context->GetIsolate();
663   v8::MicrotasksScope microtasksScope(isolate,
664                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
665 
666   v8::Local<v8::Object> console = v8::Object::New(isolate);
667   bool success =
668       console->SetPrototype(context, v8::Object::New(isolate)).FromMaybe(false);
669   DCHECK(success);
670   USE(success);
671 
672   createBoundFunctionProperty(context, console, "debug",
673                               V8Console::debugCallback);
674   createBoundFunctionProperty(context, console, "error",
675                               V8Console::errorCallback);
676   createBoundFunctionProperty(context, console, "info",
677                               V8Console::infoCallback);
678   createBoundFunctionProperty(context, console, "log", V8Console::logCallback);
679   createBoundFunctionProperty(context, console, "warn",
680                               V8Console::warnCallback);
681   createBoundFunctionProperty(context, console, "dir", V8Console::dirCallback);
682   createBoundFunctionProperty(context, console, "dirxml",
683                               V8Console::dirxmlCallback);
684   createBoundFunctionProperty(context, console, "table",
685                               V8Console::tableCallback);
686   createBoundFunctionProperty(context, console, "trace",
687                               V8Console::traceCallback);
688   createBoundFunctionProperty(context, console, "group",
689                               V8Console::groupCallback);
690   createBoundFunctionProperty(context, console, "groupCollapsed",
691                               V8Console::groupCollapsedCallback);
692   createBoundFunctionProperty(context, console, "groupEnd",
693                               V8Console::groupEndCallback);
694   createBoundFunctionProperty(context, console, "clear",
695                               V8Console::clearCallback);
696   createBoundFunctionProperty(context, console, "count",
697                               V8Console::countCallback);
698   createBoundFunctionProperty(context, console, "assert",
699                               V8Console::assertCallback);
700   createBoundFunctionProperty(context, console, "markTimeline",
701                               V8Console::markTimelineCallback);
702   createBoundFunctionProperty(context, console, "profile",
703                               V8Console::profileCallback);
704   createBoundFunctionProperty(context, console, "profileEnd",
705                               V8Console::profileEndCallback);
706   createBoundFunctionProperty(context, console, "timeline",
707                               V8Console::timelineCallback);
708   createBoundFunctionProperty(context, console, "timelineEnd",
709                               V8Console::timelineEndCallback);
710   createBoundFunctionProperty(context, console, "time",
711                               V8Console::timeCallback);
712   createBoundFunctionProperty(context, console, "timeEnd",
713                               V8Console::timeEndCallback);
714   createBoundFunctionProperty(context, console, "timeStamp",
715                               V8Console::timeStampCallback);
716 
717   if (hasMemoryAttribute)
718     console->SetAccessorProperty(
719         toV8StringInternalized(isolate, "memory"),
720         v8::Function::New(context, V8Console::memoryGetterCallback, console, 0,
721                           v8::ConstructorBehavior::kThrow)
722             .ToLocalChecked(),
723         v8::Function::New(context, V8Console::memorySetterCallback,
724                           v8::Local<v8::Value>(), 0,
725                           v8::ConstructorBehavior::kThrow)
726             .ToLocalChecked(),
727         static_cast<v8::PropertyAttribute>(v8::None), v8::DEFAULT);
728 
729   console->SetPrivate(context, inspectedContextPrivateKey(isolate),
730                       v8::External::New(isolate, inspectedContext));
731   return console;
732 }
733 
clearInspectedContextIfNeeded(v8::Local<v8::Context> context,v8::Local<v8::Object> console)734 void V8Console::clearInspectedContextIfNeeded(v8::Local<v8::Context> context,
735                                               v8::Local<v8::Object> console) {
736   v8::Isolate* isolate = context->GetIsolate();
737   console->SetPrivate(context, inspectedContextPrivateKey(isolate),
738                       v8::External::New(isolate, nullptr));
739 }
740 
createCommandLineAPI(InspectedContext * inspectedContext)741 v8::Local<v8::Object> V8Console::createCommandLineAPI(
742     InspectedContext* inspectedContext) {
743   v8::Local<v8::Context> context = inspectedContext->context();
744   v8::Isolate* isolate = context->GetIsolate();
745   v8::MicrotasksScope microtasksScope(isolate,
746                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
747 
748   v8::Local<v8::Object> commandLineAPI = v8::Object::New(isolate);
749   bool success =
750       commandLineAPI->SetPrototype(context, v8::Null(isolate)).FromMaybe(false);
751   DCHECK(success);
752   USE(success);
753 
754   createBoundFunctionProperty(context, commandLineAPI, "dir",
755                               V8Console::dirCallback,
756                               "function dir(value) { [Command Line API] }");
757   createBoundFunctionProperty(context, commandLineAPI, "dirxml",
758                               V8Console::dirxmlCallback,
759                               "function dirxml(value) { [Command Line API] }");
760   createBoundFunctionProperty(context, commandLineAPI, "profile",
761                               V8Console::profileCallback,
762                               "function profile(title) { [Command Line API] }");
763   createBoundFunctionProperty(
764       context, commandLineAPI, "profileEnd", V8Console::profileEndCallback,
765       "function profileEnd(title) { [Command Line API] }");
766   createBoundFunctionProperty(context, commandLineAPI, "clear",
767                               V8Console::clearCallback,
768                               "function clear() { [Command Line API] }");
769   createBoundFunctionProperty(
770       context, commandLineAPI, "table", V8Console::tableCallback,
771       "function table(data, [columns]) { [Command Line API] }");
772 
773   createBoundFunctionProperty(context, commandLineAPI, "keys",
774                               V8Console::keysCallback,
775                               "function keys(object) { [Command Line API] }");
776   createBoundFunctionProperty(context, commandLineAPI, "values",
777                               V8Console::valuesCallback,
778                               "function values(object) { [Command Line API] }");
779   createBoundFunctionProperty(
780       context, commandLineAPI, "debug", V8Console::debugFunctionCallback,
781       "function debug(function) { [Command Line API] }");
782   createBoundFunctionProperty(
783       context, commandLineAPI, "undebug", V8Console::undebugFunctionCallback,
784       "function undebug(function) { [Command Line API] }");
785   createBoundFunctionProperty(
786       context, commandLineAPI, "monitor", V8Console::monitorFunctionCallback,
787       "function monitor(function) { [Command Line API] }");
788   createBoundFunctionProperty(
789       context, commandLineAPI, "unmonitor",
790       V8Console::unmonitorFunctionCallback,
791       "function unmonitor(function) { [Command Line API] }");
792   createBoundFunctionProperty(
793       context, commandLineAPI, "inspect", V8Console::inspectCallback,
794       "function inspect(object) { [Command Line API] }");
795   createBoundFunctionProperty(context, commandLineAPI, "copy",
796                               V8Console::copyCallback,
797                               "function copy(value) { [Command Line API] }");
798   createBoundFunctionProperty(context, commandLineAPI, "$_",
799                               V8Console::lastEvaluationResultCallback);
800   createBoundFunctionProperty(context, commandLineAPI, "$0",
801                               V8Console::inspectedObject0);
802   createBoundFunctionProperty(context, commandLineAPI, "$1",
803                               V8Console::inspectedObject1);
804   createBoundFunctionProperty(context, commandLineAPI, "$2",
805                               V8Console::inspectedObject2);
806   createBoundFunctionProperty(context, commandLineAPI, "$3",
807                               V8Console::inspectedObject3);
808   createBoundFunctionProperty(context, commandLineAPI, "$4",
809                               V8Console::inspectedObject4);
810 
811   inspectedContext->inspector()->client()->installAdditionalCommandLineAPI(
812       context, commandLineAPI);
813 
814   commandLineAPI->SetPrivate(context, inspectedContextPrivateKey(isolate),
815                              v8::External::New(isolate, inspectedContext));
816   return commandLineAPI;
817 }
818 
isCommandLineAPIGetter(const String16 & name)819 static bool isCommandLineAPIGetter(const String16& name) {
820   if (name.length() != 2) return false;
821   // $0 ... $4, $_
822   return name[0] == '$' &&
823          ((name[1] >= '0' && name[1] <= '4') || name[1] == '_');
824 }
825 
accessorGetterCallback(v8::Local<v8::Name> name,const v8::PropertyCallbackInfo<v8::Value> & info)826 void V8Console::CommandLineAPIScope::accessorGetterCallback(
827     v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
828   CommandLineAPIScope* scope = static_cast<CommandLineAPIScope*>(
829       info.Data().As<v8::External>()->Value());
830   DCHECK(scope);
831 
832   v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
833   if (scope->m_cleanup) {
834     bool removed = info.Holder()->Delete(context, name).FromMaybe(false);
835     DCHECK(removed);
836     USE(removed);
837     return;
838   }
839   v8::Local<v8::Object> commandLineAPI = scope->m_commandLineAPI;
840 
841   v8::Local<v8::Value> value;
842   if (!commandLineAPI->Get(context, name).ToLocal(&value)) return;
843   if (isCommandLineAPIGetter(toProtocolStringWithTypeCheck(name))) {
844     DCHECK(value->IsFunction());
845     v8::MicrotasksScope microtasks(info.GetIsolate(),
846                                    v8::MicrotasksScope::kDoNotRunMicrotasks);
847     if (value.As<v8::Function>()
848             ->Call(context, commandLineAPI, 0, nullptr)
849             .ToLocal(&value))
850       info.GetReturnValue().Set(value);
851   } else {
852     info.GetReturnValue().Set(value);
853   }
854 }
855 
accessorSetterCallback(v8::Local<v8::Name> name,v8::Local<v8::Value> value,const v8::PropertyCallbackInfo<void> & info)856 void V8Console::CommandLineAPIScope::accessorSetterCallback(
857     v8::Local<v8::Name> name, v8::Local<v8::Value> value,
858     const v8::PropertyCallbackInfo<void>& info) {
859   CommandLineAPIScope* scope = static_cast<CommandLineAPIScope*>(
860       info.Data().As<v8::External>()->Value());
861   v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
862   if (!info.Holder()->Delete(context, name).FromMaybe(false)) return;
863   if (!info.Holder()->CreateDataProperty(context, name, value).FromMaybe(false))
864     return;
865   bool removed =
866       scope->m_installedMethods->Delete(context, name).FromMaybe(false);
867   DCHECK(removed);
868   USE(removed);
869 }
870 
CommandLineAPIScope(v8::Local<v8::Context> context,v8::Local<v8::Object> commandLineAPI,v8::Local<v8::Object> global)871 V8Console::CommandLineAPIScope::CommandLineAPIScope(
872     v8::Local<v8::Context> context, v8::Local<v8::Object> commandLineAPI,
873     v8::Local<v8::Object> global)
874     : m_context(context),
875       m_commandLineAPI(commandLineAPI),
876       m_global(global),
877       m_installedMethods(v8::Set::New(context->GetIsolate())),
878       m_cleanup(false) {
879   v8::Local<v8::Array> names;
880   if (!m_commandLineAPI->GetOwnPropertyNames(context).ToLocal(&names)) return;
881   v8::Local<v8::External> externalThis =
882       v8::External::New(context->GetIsolate(), this);
883   for (uint32_t i = 0; i < names->Length(); ++i) {
884     v8::Local<v8::Value> name;
885     if (!names->Get(context, i).ToLocal(&name) || !name->IsName()) continue;
886     if (m_global->Has(context, name).FromMaybe(true)) continue;
887     if (!m_installedMethods->Add(context, name).ToLocal(&m_installedMethods))
888       continue;
889     if (!m_global
890              ->SetAccessor(context, v8::Local<v8::Name>::Cast(name),
891                            CommandLineAPIScope::accessorGetterCallback,
892                            CommandLineAPIScope::accessorSetterCallback,
893                            externalThis, v8::DEFAULT, v8::DontEnum)
894              .FromMaybe(false)) {
895       bool removed = m_installedMethods->Delete(context, name).FromMaybe(false);
896       DCHECK(removed);
897       USE(removed);
898       continue;
899     }
900   }
901 }
902 
~CommandLineAPIScope()903 V8Console::CommandLineAPIScope::~CommandLineAPIScope() {
904   m_cleanup = true;
905   v8::Local<v8::Array> names = m_installedMethods->AsArray();
906   for (uint32_t i = 0; i < names->Length(); ++i) {
907     v8::Local<v8::Value> name;
908     if (!names->Get(m_context, i).ToLocal(&name) || !name->IsName()) continue;
909     if (name->IsString()) {
910       v8::Local<v8::Value> descriptor;
911       bool success = m_global
912                          ->GetOwnPropertyDescriptor(
913                              m_context, v8::Local<v8::String>::Cast(name))
914                          .ToLocal(&descriptor);
915       DCHECK(success);
916       USE(success);
917     }
918   }
919 }
920 
921 }  // namespace v8_inspector
922