Line data    Source code

       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/inspected-context.h"
       6             : 
       7             : #include "src/debug/debug-interface.h"
       8             : #include "src/inspector/injected-script.h"
       9             : #include "src/inspector/string-util.h"
      10             : #include "src/inspector/v8-console.h"
      11             : #include "src/inspector/v8-inspector-impl.h"
      12             : 
      13             : #include "include/v8-inspector.h"
      14             : 
      15             : namespace v8_inspector {
      16             : 
      17             : class InspectedContext::WeakCallbackData {
      18             :  public:
      19             :   WeakCallbackData(InspectedContext* context, V8InspectorImpl* inspector,
      20             :                    int groupId, int contextId)
      21             :       : m_context(context),
      22             :         m_inspector(inspector),
      23             :         m_groupId(groupId),
      24        3326 :         m_contextId(contextId) {}
      25             : 
      26          15 :   static void resetContext(const v8::WeakCallbackInfo<WeakCallbackData>& data) {
      27             :     // InspectedContext is alive here because weak handler is still alive.
      28           5 :     data.GetParameter()->m_context->m_weakCallbackData = nullptr;
      29           5 :     data.GetParameter()->m_context->m_context.Reset();
      30             :     data.SetSecondPassCallback(&callContextCollected);
      31           5 :   }
      32             : 
      33           5 :   static void callContextCollected(
      34           5 :       const v8::WeakCallbackInfo<WeakCallbackData>& data) {
      35             :     // InspectedContext can be dead here since anything can happen between first
      36             :     // and second pass callback.
      37             :     WeakCallbackData* callbackData = data.GetParameter();
      38             :     callbackData->m_inspector->contextCollected(callbackData->m_groupId,
      39           5 :                                                 callbackData->m_contextId);
      40           5 :     delete callbackData;
      41           5 :   }
      42             : 
      43             :  private:
      44             :   InspectedContext* m_context;
      45             :   V8InspectorImpl* m_inspector;
      46             :   int m_groupId;
      47             :   int m_contextId;
      48             : };
      49             : 
      50        3326 : InspectedContext::InspectedContext(V8InspectorImpl* inspector,
      51             :                                    const V8ContextInfo& info, int contextId)
      52             :     : m_inspector(inspector),
      53             :       m_context(info.context->GetIsolate(), info.context),
      54             :       m_contextId(contextId),
      55             :       m_contextGroupId(info.contextGroupId),
      56             :       m_origin(toString16(info.origin)),
      57             :       m_humanReadableName(toString16(info.humanReadableName)),
      58       16630 :       m_auxData(toString16(info.auxData)) {
      59        3326 :   v8::debug::SetContextId(info.context, contextId);
      60             :   m_weakCallbackData =
      61        7525 :       new WeakCallbackData(this, m_inspector, m_contextGroupId, m_contextId);
      62             :   m_context.SetWeak(m_weakCallbackData,
      63             :                     &InspectedContext::WeakCallbackData::resetContext,
      64             :                     v8::WeakCallbackType::kParameter);
      65        5779 :   if (!info.hasMemoryOnConsole) return;
      66             :   v8::Context::Scope contextScope(info.context);
      67         873 :   v8::Local<v8::Object> global = info.context->Global();
      68             :   v8::Local<v8::Value> console;
      69        3492 :   if (global->Get(info.context, toV8String(m_inspector->isolate(), "console"))
      70        2619 :           .ToLocal(&console) &&
      71         873 :       console->IsObject()) {
      72             :     m_inspector->console()->installMemoryGetter(
      73         873 :         info.context, v8::Local<v8::Object>::Cast(console));
      74             :   }
      75             : }
      76             : 
      77        3326 : InspectedContext::~InspectedContext() {
      78             :   // If we destory InspectedContext before weak callback is invoked then we need
      79             :   // to delete data here.
      80        3326 :   if (!m_context.IsEmpty()) delete m_weakCallbackData;
      81        3326 : }
      82             : 
      83             : // static
      84      722160 : int InspectedContext::contextId(v8::Local<v8::Context> context) {
      85      722160 :   return v8::debug::GetContextId(context);
      86             : }
      87             : 
      88     1214684 : v8::Local<v8::Context> InspectedContext::context() const {
      89     1214684 :   return m_context.Get(isolate());
      90             : }
      91             : 
      92     3790615 : v8::Isolate* InspectedContext::isolate() const {
      93     5005299 :   return m_inspector->isolate();
      94             : }
      95             : 
      96          25 : bool InspectedContext::isReported(int sessionId) const {
      97          25 :   return m_reportedSessionIds.find(sessionId) != m_reportedSessionIds.cend();
      98             : }
      99             : 
     100         640 : void InspectedContext::setReported(int sessionId, bool reported) {
     101         640 :   if (reported)
     102             :     m_reportedSessionIds.insert(sessionId);
     103             :   else
     104             :     m_reportedSessionIds.erase(sessionId);
     105         640 : }
     106             : 
     107      278463 : InjectedScript* InspectedContext::getInjectedScript(int sessionId) {
     108             :   auto it = m_injectedScripts.find(sessionId);
     109      556926 :   return it == m_injectedScripts.end() ? nullptr : it->second.get();
     110             : }
     111             : 
     112        2944 : bool InspectedContext::createInjectedScript(int sessionId) {
     113             :   DCHECK(m_injectedScripts.find(sessionId) == m_injectedScripts.end());
     114             :   std::unique_ptr<InjectedScript> injectedScript =
     115        2944 :       InjectedScript::create(this, sessionId);
     116             :   // InjectedScript::create can destroy |this|.
     117        2944 :   if (!injectedScript) return false;
     118             :   m_injectedScripts[sessionId] = std::move(injectedScript);
     119             :   return true;
     120             : }
     121             : 
     122        3396 : void InspectedContext::discardInjectedScript(int sessionId) {
     123             :   m_injectedScripts.erase(sessionId);
     124        3396 : }
     125             : 
     126             : }  // namespace v8_inspector