Home | History | Annotate | Download | only in inspector 
      1 /*
      2  * Copyright (c) 2010-2011 Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include "src/inspector/v8-inspector-impl.h"
     32 
     33 #include "src/inspector/inspected-context.h"
     34 #include "src/inspector/string-util.h"
     35 #include "src/inspector/v8-console-agent-impl.h"
     36 #include "src/inspector/v8-console-message.h"
     37 #include "src/inspector/v8-debugger-agent-impl.h"
     38 #include "src/inspector/v8-debugger.h"
     39 #include "src/inspector/v8-inspector-session-impl.h"
     40 #include "src/inspector/v8-profiler-agent-impl.h"
     41 #include "src/inspector/v8-runtime-agent-impl.h"
     42 #include "src/inspector/v8-stack-trace-impl.h"
     43 
     44 namespace v8_inspector {
     45 
     46 std::unique_ptr<V8Inspector> V8Inspector::create(v8::Isolate* isolate,
     47                                                  V8InspectorClient* client) {
     48   return std::unique_ptr<V8Inspector>(new V8InspectorImpl(isolate, client));
     49 }
     50 
     51 V8InspectorImpl::V8InspectorImpl(v8::Isolate* isolate,
     52                                  V8InspectorClient* client)
     53     : m_isolate(isolate),
     54       m_client(client),
     55       m_debugger(new V8Debugger(isolate, this)),
     56       m_capturingStackTracesCount(0),
     57       m_lastExceptionId(0),
     58       m_lastContextId(0) {}
     59 
     60 V8InspectorImpl::~V8InspectorImpl() {}
     61 
     62 int V8InspectorImpl::contextGroupId(v8::Local<v8::Context> context) {
     63   return contextGroupId(InspectedContext::contextId(context));
     64 }
     65 
     66 int V8InspectorImpl::contextGroupId(int contextId) {
     67   protocol::HashMap<int, int>::iterator it =
     68       m_contextIdToGroupIdMap.find(contextId);
     69   return it != m_contextIdToGroupIdMap.end() ? it->second : 0;
     70 }
     71 
     72 V8DebuggerAgentImpl* V8InspectorImpl::enabledDebuggerAgentForGroup(
     73     int contextGroupId) {
     74   V8InspectorSessionImpl* session = sessionForContextGroup(contextGroupId);
     75   V8DebuggerAgentImpl* agent = session ? session->debuggerAgent() : nullptr;
     76   return agent && agent->enabled() ? agent : nullptr;
     77 }
     78 
     79 V8RuntimeAgentImpl* V8InspectorImpl::enabledRuntimeAgentForGroup(
     80     int contextGroupId) {
     81   V8InspectorSessionImpl* session = sessionForContextGroup(contextGroupId);
     82   V8RuntimeAgentImpl* agent = session ? session->runtimeAgent() : nullptr;
     83   return agent && agent->enabled() ? agent : nullptr;
     84 }
     85 
     86 V8ProfilerAgentImpl* V8InspectorImpl::enabledProfilerAgentForGroup(
     87     int contextGroupId) {
     88   V8InspectorSessionImpl* session = sessionForContextGroup(contextGroupId);
     89   V8ProfilerAgentImpl* agent = session ? session->profilerAgent() : nullptr;
     90   return agent && agent->enabled() ? agent : nullptr;
     91 }
     92 
     93 v8::MaybeLocal<v8::Value> V8InspectorImpl::runCompiledScript(
     94     v8::Local<v8::Context> context, v8::Local<v8::Script> script) {
     95   v8::MicrotasksScope microtasksScope(m_isolate,
     96                                       v8::MicrotasksScope::kRunMicrotasks);
     97   int groupId = contextGroupId(context);
     98   if (V8DebuggerAgentImpl* agent = enabledDebuggerAgentForGroup(groupId))
     99     agent->willExecuteScript(script->GetUnboundScript()->GetId());
    100   v8::MaybeLocal<v8::Value> result = script->Run(context);
    101   // Get agent from the map again, since it could have detached during script
    102   // execution.
    103   if (V8DebuggerAgentImpl* agent = enabledDebuggerAgentForGroup(groupId))
    104     agent->didExecuteScript();
    105   return result;
    106 }
    107 
    108 v8::MaybeLocal<v8::Value> V8InspectorImpl::callFunction(
    109     v8::Local<v8::Function> function, v8::Local<v8::Context> context,
    110     v8::Local<v8::Value> receiver, int argc, v8::Local<v8::Value> info[]) {
    111   return callFunction(function, context, receiver, argc, info,
    112                       v8::MicrotasksScope::kRunMicrotasks);
    113 }
    114 
    115 v8::MaybeLocal<v8::Value> V8InspectorImpl::callInternalFunction(
    116     v8::Local<v8::Function> function, v8::Local<v8::Context> context,
    117     v8::Local<v8::Value> receiver, int argc, v8::Local<v8::Value> info[]) {
    118   return callFunction(function, context, receiver, argc, info,
    119                       v8::MicrotasksScope::kDoNotRunMicrotasks);
    120 }
    121 
    122 v8::MaybeLocal<v8::Value> V8InspectorImpl::callFunction(
    123     v8::Local<v8::Function> function, v8::Local<v8::Context> context,
    124     v8::Local<v8::Value> receiver, int argc, v8::Local<v8::Value> info[],
    125     v8::MicrotasksScope::Type runMicrotasks) {
    126   v8::MicrotasksScope microtasksScope(m_isolate, runMicrotasks);
    127   int groupId = contextGroupId(context);
    128   if (V8DebuggerAgentImpl* agent = enabledDebuggerAgentForGroup(groupId))
    129     agent->willExecuteScript(function->ScriptId());
    130   v8::MaybeLocal<v8::Value> result =
    131       function->Call(context, receiver, argc, info);
    132   // Get agent from the map again, since it could have detached during script
    133   // execution.
    134   if (V8DebuggerAgentImpl* agent = enabledDebuggerAgentForGroup(groupId))
    135     agent->didExecuteScript();
    136   return result;
    137 }
    138 
    139 v8::MaybeLocal<v8::Value> V8InspectorImpl::compileAndRunInternalScript(
    140     v8::Local<v8::Context> context, v8::Local<v8::String> source) {
    141   v8::Local<v8::UnboundScript> unboundScript;
    142   if (!v8::debug::CompileInspectorScript(m_isolate, source)
    143            .ToLocal(&unboundScript))
    144     return v8::MaybeLocal<v8::Value>();
    145   v8::MicrotasksScope microtasksScope(m_isolate,
    146                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
    147   v8::Context::Scope contextScope(context);
    148   return unboundScript->BindToCurrentContext()->Run(context);
    149 }
    150 
    151 v8::MaybeLocal<v8::Script> V8InspectorImpl::compileScript(
    152     v8::Local<v8::Context> context, const String16& code,
    153     const String16& fileName) {
    154   v8::ScriptOrigin origin(
    155       toV8String(m_isolate, fileName), v8::Integer::New(m_isolate, 0),
    156       v8::Integer::New(m_isolate, 0),
    157       v8::False(m_isolate),                                         // sharable
    158       v8::Local<v8::Integer>(), toV8String(m_isolate, String16()),  // sourceMap
    159       v8::True(m_isolate));  // opaqueresource
    160   v8::ScriptCompiler::Source source(toV8String(m_isolate, code), origin);
    161   return v8::ScriptCompiler::Compile(context, &source,
    162                                      v8::ScriptCompiler::kNoCompileOptions);
    163 }
    164 
    165 void V8InspectorImpl::enableStackCapturingIfNeeded() {
    166   if (!m_capturingStackTracesCount)
    167     V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(m_isolate,
    168                                                                 true);
    169   ++m_capturingStackTracesCount;
    170 }
    171 
    172 void V8InspectorImpl::disableStackCapturingIfNeeded() {
    173   if (!(--m_capturingStackTracesCount))
    174     V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(m_isolate,
    175                                                                 false);
    176 }
    177 
    178 void V8InspectorImpl::muteExceptions(int contextGroupId) {
    179   m_muteExceptionsMap[contextGroupId]++;
    180 }
    181 
    182 void V8InspectorImpl::unmuteExceptions(int contextGroupId) {
    183   m_muteExceptionsMap[contextGroupId]--;
    184 }
    185 
    186 V8ConsoleMessageStorage* V8InspectorImpl::ensureConsoleMessageStorage(
    187     int contextGroupId) {
    188   ConsoleStorageMap::iterator storageIt =
    189       m_consoleStorageMap.find(contextGroupId);
    190   if (storageIt == m_consoleStorageMap.end())
    191     storageIt = m_consoleStorageMap
    192                     .insert(std::make_pair(
    193                         contextGroupId,
    194                         std::unique_ptr<V8ConsoleMessageStorage>(
    195                             new V8ConsoleMessageStorage(this, contextGroupId))))
    196                     .first;
    197   return storageIt->second.get();
    198 }
    199 
    200 bool V8InspectorImpl::hasConsoleMessageStorage(int contextGroupId) {
    201   ConsoleStorageMap::iterator storageIt =
    202       m_consoleStorageMap.find(contextGroupId);
    203   return storageIt != m_consoleStorageMap.end();
    204 }
    205 
    206 std::unique_ptr<V8StackTrace> V8InspectorImpl::createStackTrace(
    207     v8::Local<v8::StackTrace> stackTrace) {
    208   return m_debugger->createStackTrace(stackTrace);
    209 }
    210 
    211 std::unique_ptr<V8InspectorSession> V8InspectorImpl::connect(
    212     int contextGroupId, V8Inspector::Channel* channel,
    213     const StringView& state) {
    214   DCHECK(m_sessions.find(contextGroupId) == m_sessions.cend());
    215   std::unique_ptr<V8InspectorSessionImpl> session =
    216       V8InspectorSessionImpl::create(this, contextGroupId, channel, state);
    217   m_sessions[contextGroupId] = session.get();
    218   return std::move(session);
    219 }
    220 
    221 void V8InspectorImpl::disconnect(V8InspectorSessionImpl* session) {
    222   DCHECK(m_sessions.find(session->contextGroupId()) != m_sessions.end());
    223   m_sessions.erase(session->contextGroupId());
    224 }
    225 
    226 InspectedContext* V8InspectorImpl::getContext(int groupId,
    227                                               int contextId) const {
    228   if (!groupId || !contextId) return nullptr;
    229 
    230   ContextsByGroupMap::const_iterator contextGroupIt = m_contexts.find(groupId);
    231   if (contextGroupIt == m_contexts.end()) return nullptr;
    232 
    233   ContextByIdMap::iterator contextIt = contextGroupIt->second->find(contextId);
    234   if (contextIt == contextGroupIt->second->end()) return nullptr;
    235 
    236   return contextIt->second.get();
    237 }
    238 
    239 void V8InspectorImpl::contextCreated(const V8ContextInfo& info) {
    240   int contextId = ++m_lastContextId;
    241   InspectedContext* context = new InspectedContext(this, info, contextId);
    242   m_contextIdToGroupIdMap[contextId] = info.contextGroupId;
    243 
    244   ContextsByGroupMap::iterator contextIt = m_contexts.find(info.contextGroupId);
    245   if (contextIt == m_contexts.end())
    246     contextIt = m_contexts
    247                     .insert(std::make_pair(
    248                         info.contextGroupId,
    249                         std::unique_ptr<ContextByIdMap>(new ContextByIdMap())))
    250                     .first;
    251   const auto& contextById = contextIt->second;
    252 
    253   DCHECK(contextById->find(contextId) == contextById->cend());
    254   (*contextById)[contextId].reset(context);
    255   SessionMap::iterator sessionIt = m_sessions.find(info.contextGroupId);
    256   if (sessionIt != m_sessions.end())
    257     sessionIt->second->runtimeAgent()->reportExecutionContextCreated(context);
    258 }
    259 
    260 void V8InspectorImpl::contextDestroyed(v8::Local<v8::Context> context) {
    261   int contextId = InspectedContext::contextId(context);
    262   int groupId = contextGroupId(context);
    263   m_contextIdToGroupIdMap.erase(contextId);
    264 
    265   ConsoleStorageMap::iterator storageIt = m_consoleStorageMap.find(groupId);
    266   if (storageIt != m_consoleStorageMap.end())
    267     storageIt->second->contextDestroyed(contextId);
    268 
    269   InspectedContext* inspectedContext = getContext(groupId, contextId);
    270   if (!inspectedContext) return;
    271 
    272   SessionMap::iterator iter = m_sessions.find(groupId);
    273   if (iter != m_sessions.end())
    274     iter->second->runtimeAgent()->reportExecutionContextDestroyed(
    275         inspectedContext);
    276   discardInspectedContext(groupId, contextId);
    277 }
    278 
    279 void V8InspectorImpl::resetContextGroup(int contextGroupId) {
    280   m_consoleStorageMap.erase(contextGroupId);
    281   m_muteExceptionsMap.erase(contextGroupId);
    282   SessionMap::iterator session = m_sessions.find(contextGroupId);
    283   if (session != m_sessions.end()) session->second->reset();
    284   m_contexts.erase(contextGroupId);
    285   m_debugger->wasmTranslation()->Clear();
    286 }
    287 
    288 void V8InspectorImpl::willExecuteScript(v8::Local<v8::Context> context,
    289                                         int scriptId) {
    290   if (V8DebuggerAgentImpl* agent =
    291           enabledDebuggerAgentForGroup(contextGroupId(context))) {
    292     agent->willExecuteScript(scriptId);
    293   }
    294 }
    295 
    296 void V8InspectorImpl::didExecuteScript(v8::Local<v8::Context> context) {
    297   if (V8DebuggerAgentImpl* agent =
    298           enabledDebuggerAgentForGroup(contextGroupId(context))) {
    299     agent->didExecuteScript();
    300   }
    301 }
    302 
    303 void V8InspectorImpl::idleStarted() {
    304   for (auto it = m_sessions.begin(); it != m_sessions.end(); ++it) {
    305     if (it->second->profilerAgent()->idleStarted()) return;
    306   }
    307 }
    308 
    309 void V8InspectorImpl::idleFinished() {
    310   for (auto it = m_sessions.begin(); it != m_sessions.end(); ++it) {
    311     if (it->second->profilerAgent()->idleFinished()) return;
    312   }
    313 }
    314 
    315 unsigned V8InspectorImpl::exceptionThrown(
    316     v8::Local<v8::Context> context, const StringView& message,
    317     v8::Local<v8::Value> exception, const StringView& detailedMessage,
    318     const StringView& url, unsigned lineNumber, unsigned columnNumber,
    319     std::unique_ptr<V8StackTrace> stackTrace, int scriptId) {
    320   int groupId = contextGroupId(context);
    321   if (!groupId || m_muteExceptionsMap[groupId]) return 0;
    322   std::unique_ptr<V8StackTraceImpl> stackTraceImpl(
    323       static_cast<V8StackTraceImpl*>(stackTrace.release()));
    324   unsigned exceptionId = nextExceptionId();
    325   std::unique_ptr<V8ConsoleMessage> consoleMessage =
    326       V8ConsoleMessage::createForException(
    327           m_client->currentTimeMS(), toString16(detailedMessage),
    328           toString16(url), lineNumber, columnNumber, std::move(stackTraceImpl),
    329           scriptId, m_isolate, toString16(message),
    330           InspectedContext::contextId(context), exception, exceptionId);
    331   ensureConsoleMessageStorage(groupId)->addMessage(std::move(consoleMessage));
    332   return exceptionId;
    333 }
    334 
    335 void V8InspectorImpl::exceptionRevoked(v8::Local<v8::Context> context,
    336                                        unsigned exceptionId,
    337                                        const StringView& message) {
    338   int groupId = contextGroupId(context);
    339   if (!groupId) return;
    340 
    341   std::unique_ptr<V8ConsoleMessage> consoleMessage =
    342       V8ConsoleMessage::createForRevokedException(
    343           m_client->currentTimeMS(), toString16(message), exceptionId);
    344   ensureConsoleMessageStorage(groupId)->addMessage(std::move(consoleMessage));
    345 }
    346 
    347 std::unique_ptr<V8StackTrace> V8InspectorImpl::captureStackTrace(
    348     bool fullStack) {
    349   return m_debugger->captureStackTrace(fullStack);
    350 }
    351 
    352 void V8InspectorImpl::asyncTaskScheduled(const StringView& taskName, void* task,
    353                                          bool recurring) {
    354   m_debugger->asyncTaskScheduled(taskName, task, recurring);
    355 }
    356 
    357 void V8InspectorImpl::asyncTaskCanceled(void* task) {
    358   m_debugger->asyncTaskCanceled(task);
    359 }
    360 
    361 void V8InspectorImpl::asyncTaskStarted(void* task) {
    362   m_debugger->asyncTaskStarted(task);
    363 }
    364 
    365 void V8InspectorImpl::asyncTaskFinished(void* task) {
    366   m_debugger->asyncTaskFinished(task);
    367 }
    368 
    369 void V8InspectorImpl::allAsyncTasksCanceled() {
    370   m_debugger->allAsyncTasksCanceled();
    371 }
    372 
    373 v8::Local<v8::Context> V8InspectorImpl::regexContext() {
    374   if (m_regexContext.IsEmpty())
    375     m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
    376   return m_regexContext.Get(m_isolate);
    377 }
    378 
    379 void V8InspectorImpl::discardInspectedContext(int contextGroupId,
    380                                               int contextId) {
    381   if (!getContext(contextGroupId, contextId)) return;
    382   m_contexts[contextGroupId]->erase(contextId);
    383   if (m_contexts[contextGroupId]->empty()) m_contexts.erase(contextGroupId);
    384 }
    385 
    386 const V8InspectorImpl::ContextByIdMap* V8InspectorImpl::contextGroup(
    387     int contextGroupId) {
    388   ContextsByGroupMap::iterator iter = m_contexts.find(contextGroupId);
    389   return iter == m_contexts.end() ? nullptr : iter->second.get();
    390 }
    391 
    392 V8InspectorSessionImpl* V8InspectorImpl::sessionForContextGroup(
    393     int contextGroupId) {
    394   if (!contextGroupId) return nullptr;
    395   SessionMap::iterator iter = m_sessions.find(contextGroupId);
    396   return iter == m_sessions.end() ? nullptr : iter->second;
    397 }
    398 
    399 }  // namespace v8_inspector
    400