LCOV - code coverage report
Current view: top level - src/inspector - injected-script.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 249 263 94.7 %
Date: 2017-04-26 Functions: 35 41 85.4 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2012 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/injected-script.h"
      32             : 
      33             : #include "src/inspector/injected-script-native.h"
      34             : #include "src/inspector/injected-script-source.h"
      35             : #include "src/inspector/inspected-context.h"
      36             : #include "src/inspector/protocol/Protocol.h"
      37             : #include "src/inspector/remote-object-id.h"
      38             : #include "src/inspector/string-util.h"
      39             : #include "src/inspector/v8-console.h"
      40             : #include "src/inspector/v8-function-call.h"
      41             : #include "src/inspector/v8-injected-script-host.h"
      42             : #include "src/inspector/v8-inspector-impl.h"
      43             : #include "src/inspector/v8-inspector-session-impl.h"
      44             : #include "src/inspector/v8-stack-trace-impl.h"
      45             : #include "src/inspector/v8-value-copier.h"
      46             : 
      47             : #include "include/v8-inspector.h"
      48             : 
      49             : namespace v8_inspector {
      50             : 
      51             : using protocol::Array;
      52             : using protocol::Runtime::PropertyDescriptor;
      53             : using protocol::Runtime::InternalPropertyDescriptor;
      54             : using protocol::Runtime::RemoteObject;
      55             : using protocol::Maybe;
      56             : 
      57        4109 : std::unique_ptr<InjectedScript> InjectedScript::create(
      58       16436 :     InspectedContext* inspectedContext) {
      59        4109 :   v8::Isolate* isolate = inspectedContext->isolate();
      60        4109 :   v8::HandleScope handles(isolate);
      61        4109 :   v8::Local<v8::Context> context = inspectedContext->context();
      62             :   v8::Context::Scope scope(context);
      63             : 
      64             :   std::unique_ptr<InjectedScriptNative> injectedScriptNative(
      65        4109 :       new InjectedScriptNative(isolate));
      66             :   v8::Local<v8::Object> scriptHostWrapper =
      67        4109 :       V8InjectedScriptHost::create(context, inspectedContext->inspector());
      68        4109 :   injectedScriptNative->setOnInjectedScriptHost(scriptHostWrapper);
      69             : 
      70             :   // Inject javascript into the context. The compiled script is supposed to
      71             :   // evaluate into
      72             :   // a single anonymous function(it's anonymous to avoid cluttering the global
      73             :   // object with
      74             :   // inspector's stuff) the function is called a few lines below with
      75             :   // InjectedScriptHost wrapper,
      76             :   // injected script id and explicit reference to the inspected global object.
      77             :   // The function is expected
      78             :   // to create and configure InjectedScript instance that is going to be used by
      79             :   // the inspector.
      80             :   String16 injectedScriptSource(
      81             :       reinterpret_cast<const char*>(InjectedScriptSource_js),
      82        4109 :       sizeof(InjectedScriptSource_js));
      83             :   v8::Local<v8::Value> value;
      84        4109 :   if (!inspectedContext->inspector()
      85             :            ->compileAndRunInternalScript(
      86        4109 :                context, toV8String(isolate, injectedScriptSource))
      87        8218 :            .ToLocal(&value))
      88             :     return nullptr;
      89             :   DCHECK(value->IsFunction());
      90             :   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(value);
      91        4109 :   v8::Local<v8::Object> windowGlobal = context->Global();
      92             :   v8::Local<v8::Value> info[] = {
      93             :       scriptHostWrapper, windowGlobal,
      94        4109 :       v8::Number::New(isolate, inspectedContext->contextId())};
      95             :   v8::MicrotasksScope microtasksScope(isolate,
      96        8218 :                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
      97             : 
      98             :   int contextGroupId = inspectedContext->contextGroupId();
      99             :   int contextId = inspectedContext->contextId();
     100             :   V8InspectorImpl* inspector = inspectedContext->inspector();
     101             :   v8::Local<v8::Value> injectedScriptValue;
     102        4109 :   if (!function->Call(context, windowGlobal, arraysize(info), info)
     103        8218 :            .ToLocal(&injectedScriptValue))
     104             :     return nullptr;
     105        4109 :   if (inspector->getContext(contextGroupId, contextId) != inspectedContext)
     106             :     return nullptr;
     107        4109 :   if (!injectedScriptValue->IsObject()) return nullptr;
     108             :   return std::unique_ptr<InjectedScript>(
     109             :       new InjectedScript(inspectedContext, injectedScriptValue.As<v8::Object>(),
     110       16436 :                          std::move(injectedScriptNative)));
     111             : }
     112             : 
     113        4109 : InjectedScript::InjectedScript(
     114             :     InspectedContext* context, v8::Local<v8::Object> object,
     115             :     std::unique_ptr<InjectedScriptNative> injectedScriptNative)
     116             :     : m_context(context),
     117             :       m_value(context->isolate(), object),
     118        8218 :       m_native(std::move(injectedScriptNative)) {}
     119             : 
     120        8218 : InjectedScript::~InjectedScript() {}
     121             : 
     122      106248 : Response InjectedScript::getProperties(
     123             :     v8::Local<v8::Object> object, const String16& groupName, bool ownProperties,
     124             :     bool accessorPropertiesOnly, bool generatePreview,
     125             :     std::unique_ptr<Array<PropertyDescriptor>>* properties,
     126             :     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
     127      212496 :   v8::HandleScope handles(m_context->isolate());
     128      106248 :   v8::Local<v8::Context> context = m_context->context();
     129             :   V8FunctionCall function(m_context->inspector(), m_context->context(),
     130      318744 :                           v8Value(), "getProperties");
     131      106248 :   function.appendArgument(object);
     132      106248 :   function.appendArgument(groupName);
     133      106248 :   function.appendArgument(ownProperties);
     134      106248 :   function.appendArgument(accessorPropertiesOnly);
     135      106248 :   function.appendArgument(generatePreview);
     136             : 
     137      212496 :   v8::TryCatch tryCatch(m_context->isolate());
     138      106248 :   v8::Local<v8::Value> resultValue = function.callWithoutExceptionHandling();
     139      106248 :   if (tryCatch.HasCaught()) {
     140             :     Response response = createExceptionDetails(
     141           0 :         tryCatch, groupName, generatePreview, exceptionDetails);
     142           0 :     if (!response.isSuccess()) return response;
     143             :     // FIXME: make properties optional
     144             :     *properties = Array<PropertyDescriptor>::create();
     145           0 :     return Response::OK();
     146             :   }
     147      106248 :   if (resultValue.IsEmpty()) return Response::InternalError();
     148      106248 :   std::unique_ptr<protocol::Value> protocolValue;
     149      106248 :   Response response = toProtocolValue(context, resultValue, &protocolValue);
     150      106248 :   if (!response.isSuccess()) return response;
     151      212496 :   protocol::ErrorSupport errors;
     152             :   std::unique_ptr<Array<PropertyDescriptor>> result =
     153      106248 :       Array<PropertyDescriptor>::fromValue(protocolValue.get(), &errors);
     154      106248 :   if (errors.hasErrors()) return Response::Error(errors.errors());
     155             :   *properties = std::move(result);
     156      212496 :   return Response::OK();
     157             : }
     158             : 
     159           6 : void InjectedScript::releaseObject(const String16& objectId) {
     160             :   std::unique_ptr<protocol::Value> parsedObjectId =
     161           6 :       protocol::StringUtil::parseJSON(objectId);
     162           6 :   if (!parsedObjectId) return;
     163             :   protocol::DictionaryValue* object =
     164             :       protocol::DictionaryValue::cast(parsedObjectId.get());
     165           6 :   if (!object) return;
     166           6 :   int boundId = 0;
     167          12 :   if (!object->getInteger("id", &boundId)) return;
     168          12 :   m_native->unbind(boundId);
     169             : }
     170             : 
     171       31965 : Response InjectedScript::wrapObject(
     172             :     v8::Local<v8::Value> value, const String16& groupName, bool forceValueType,
     173             :     bool generatePreview,
     174             :     std::unique_ptr<protocol::Runtime::RemoteObject>* result) const {
     175       31965 :   v8::HandleScope handles(m_context->isolate());
     176             :   v8::Local<v8::Value> wrappedObject;
     177       31965 :   v8::Local<v8::Context> context = m_context->context();
     178             :   Response response = wrapValue(value, groupName, forceValueType,
     179       31965 :                                 generatePreview, &wrappedObject);
     180       31965 :   if (!response.isSuccess()) return response;
     181       63900 :   protocol::ErrorSupport errors;
     182       31950 :   std::unique_ptr<protocol::Value> protocolValue;
     183       63900 :   response = toProtocolValue(context, wrappedObject, &protocolValue);
     184       31950 :   if (!response.isSuccess()) return response;
     185             : 
     186       63888 :   *result =
     187             :       protocol::Runtime::RemoteObject::fromValue(protocolValue.get(), &errors);
     188       31944 :   if (!result->get()) return Response::Error(errors.errors());
     189       63909 :   return Response::OK();
     190             : }
     191             : 
     192      200104 : Response InjectedScript::wrapObjectProperty(v8::Local<v8::Object> object,
     193             :                                             v8::Local<v8::Name> key,
     194             :                                             const String16& groupName,
     195             :                                             bool forceValueType,
     196             :                                             bool generatePreview) const {
     197             :   v8::Local<v8::Value> property;
     198      200104 :   v8::Local<v8::Context> context = m_context->context();
     199      400208 :   if (!object->Get(context, key).ToLocal(&property))
     200           0 :     return Response::InternalError();
     201             :   v8::Local<v8::Value> wrappedProperty;
     202             :   Response response = wrapValue(property, groupName, forceValueType,
     203      200104 :                                 generatePreview, &wrappedProperty);
     204      200104 :   if (!response.isSuccess()) return response;
     205             :   v8::Maybe<bool> success =
     206      200102 :       createDataProperty(context, object, key, wrappedProperty);
     207      400204 :   if (success.IsNothing() || !success.FromJust())
     208           0 :     return Response::InternalError();
     209      200102 :   return Response::OK();
     210             : }
     211             : 
     212      191418 : Response InjectedScript::wrapPropertyInArray(v8::Local<v8::Array> array,
     213             :                                              v8::Local<v8::String> property,
     214             :                                              const String16& groupName,
     215             :                                              bool forceValueType,
     216             :                                              bool generatePreview) const {
     217             :   V8FunctionCall function(m_context->inspector(), m_context->context(),
     218      382836 :                           v8Value(), "wrapPropertyInArray");
     219      191418 :   function.appendArgument(array);
     220      191418 :   function.appendArgument(property);
     221      191418 :   function.appendArgument(groupName);
     222      191418 :   function.appendArgument(forceValueType);
     223      191418 :   function.appendArgument(generatePreview);
     224      191418 :   bool hadException = false;
     225      191418 :   function.call(hadException);
     226      382836 :   return hadException ? Response::InternalError() : Response::OK();
     227             : }
     228             : 
     229      232069 : Response InjectedScript::wrapValue(v8::Local<v8::Value> value,
     230             :                                    const String16& groupName,
     231             :                                    bool forceValueType, bool generatePreview,
     232             :                                    v8::Local<v8::Value>* result) const {
     233             :   V8FunctionCall function(m_context->inspector(), m_context->context(),
     234      464138 :                           v8Value(), "wrapObject");
     235      232069 :   function.appendArgument(value);
     236      232069 :   function.appendArgument(groupName);
     237      232069 :   function.appendArgument(forceValueType);
     238      232069 :   function.appendArgument(generatePreview);
     239      232069 :   bool hadException = false;
     240      232069 :   *result = function.call(hadException);
     241      464121 :   if (hadException || result->IsEmpty()) return Response::InternalError();
     242      232052 :   return Response::OK();
     243             : }
     244             : 
     245         120 : std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapTable(
     246             :     v8::Local<v8::Value> table, v8::Local<v8::Value> columns) const {
     247         240 :   v8::HandleScope handles(m_context->isolate());
     248         120 :   v8::Local<v8::Context> context = m_context->context();
     249             :   V8FunctionCall function(m_context->inspector(), context, v8Value(),
     250         360 :                           "wrapTable");
     251         120 :   function.appendArgument(table);
     252         120 :   if (columns.IsEmpty())
     253         120 :     function.appendArgument(false);
     254             :   else
     255           0 :     function.appendArgument(columns);
     256         120 :   bool hadException = false;
     257         120 :   v8::Local<v8::Value> r = function.call(hadException);
     258         240 :   if (hadException || r.IsEmpty()) return nullptr;
     259         120 :   std::unique_ptr<protocol::Value> protocolValue;
     260         120 :   Response response = toProtocolValue(context, r, &protocolValue);
     261         120 :   if (!response.isSuccess()) return nullptr;
     262         240 :   protocol::ErrorSupport errors;
     263             :   return protocol::Runtime::RemoteObject::fromValue(protocolValue.get(),
     264         240 :                                                     &errors);
     265             : }
     266             : 
     267      107328 : Response InjectedScript::findObject(const RemoteObjectId& objectId,
     268             :                                     v8::Local<v8::Value>* outObject) const {
     269      107328 :   *outObject = m_native->objectForId(objectId.id());
     270      107328 :   if (outObject->IsEmpty())
     271           0 :     return Response::Error("Could not find object with given id");
     272      107328 :   return Response::OK();
     273             : }
     274             : 
     275      107298 : String16 InjectedScript::objectGroupName(const RemoteObjectId& objectId) const {
     276      107298 :   return m_native->groupName(objectId.id());
     277             : }
     278             : 
     279       64524 : void InjectedScript::releaseObjectGroup(const String16& objectGroup) {
     280       64524 :   m_native->releaseObjectGroup(objectGroup);
     281      129048 :   if (objectGroup == "console") m_lastEvaluationResult.Reset();
     282       64524 : }
     283             : 
     284           6 : void InjectedScript::setCustomObjectFormatterEnabled(bool enabled) {
     285          12 :   v8::HandleScope handles(m_context->isolate());
     286             :   V8FunctionCall function(m_context->inspector(), m_context->context(),
     287          18 :                           v8Value(), "setCustomObjectFormatterEnabled");
     288           6 :   function.appendArgument(enabled);
     289           6 :   bool hadException = false;
     290           6 :   function.call(hadException);
     291           6 :   DCHECK(!hadException);
     292           6 : }
     293             : 
     294      529861 : v8::Local<v8::Value> InjectedScript::v8Value() const {
     295     1059722 :   return m_value.Get(m_context->isolate());
     296             : }
     297             : 
     298          66 : v8::Local<v8::Value> InjectedScript::lastEvaluationResult() const {
     299          66 :   if (m_lastEvaluationResult.IsEmpty())
     300          12 :     return v8::Undefined(m_context->isolate());
     301          60 :   return m_lastEvaluationResult.Get(m_context->isolate());
     302             : }
     303             : 
     304         212 : Response InjectedScript::resolveCallArgument(
     305             :     protocol::Runtime::CallArgument* callArgument,
     306             :     v8::Local<v8::Value>* result) {
     307         212 :   if (callArgument->hasObjectId()) {
     308          30 :     std::unique_ptr<RemoteObjectId> remoteObjectId;
     309             :     Response response =
     310          90 :         RemoteObjectId::parse(callArgument->getObjectId(""), &remoteObjectId);
     311          30 :     if (!response.isSuccess()) return response;
     312         206 :     if (remoteObjectId->contextId() != m_context->contextId())
     313             :       return Response::Error(
     314             :           "Argument should belong to the same JavaScript world as target "
     315           0 :           "object");
     316          30 :     return findObject(*remoteObjectId, result);
     317             :   }
     318         194 :   if (callArgument->hasValue() || callArgument->hasUnserializableValue()) {
     319             :     String16 value =
     320             :         callArgument->hasValue()
     321         170 :             ? callArgument->getValue(nullptr)->serialize()
     322         370 :             : "Number(\"" + callArgument->getUnserializableValue("") + "\")";
     323         176 :     if (!m_context->inspector()
     324             :              ->compileAndRunInternalScript(
     325         176 :                  m_context->context(), toV8String(m_context->isolate(), value))
     326         352 :              .ToLocal(result)) {
     327           0 :       return Response::Error("Couldn't parse value object in call argument");
     328             :     }
     329         176 :     return Response::OK();
     330             :   }
     331          12 :   *result = v8::Undefined(m_context->isolate());
     332           6 :   return Response::OK();
     333             : }
     334             : 
     335        1590 : Response InjectedScript::createExceptionDetails(
     336             :     const v8::TryCatch& tryCatch, const String16& objectGroup,
     337             :     bool generatePreview, Maybe<protocol::Runtime::ExceptionDetails>* result) {
     338        1590 :   if (!tryCatch.HasCaught()) return Response::InternalError();
     339        1590 :   v8::Local<v8::Message> message = tryCatch.Message();
     340        1590 :   v8::Local<v8::Value> exception = tryCatch.Exception();
     341             :   String16 messageText =
     342        3180 :       message.IsEmpty() ? String16() : toProtocolString(message->Get());
     343             :   std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
     344             :       protocol::Runtime::ExceptionDetails::create()
     345        4770 :           .setExceptionId(m_context->inspector()->nextExceptionId())
     346        4770 :           .setText(exception.IsEmpty() ? messageText : String16("Uncaught"))
     347             :           .setLineNumber(
     348             :               message.IsEmpty()
     349             :                   ? 0
     350        3180 :                   : message->GetLineNumber(m_context->context()).FromMaybe(1) -
     351        3180 :                         1)
     352             :           .setColumnNumber(
     353             :               message.IsEmpty()
     354             :                   ? 0
     355        4806 :                   : message->GetStartColumn(m_context->context()).FromMaybe(0))
     356             :           .build();
     357        1590 :   if (!message.IsEmpty()) {
     358             :     exceptionDetails->setScriptId(String16::fromInteger(
     359        3180 :         static_cast<int>(message->GetScriptOrigin().ScriptID()->Value())));
     360        1590 :     v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
     361        1590 :     if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
     362             :       exceptionDetails->setStackTrace(m_context->inspector()
     363             :                                           ->debugger()
     364             :                                           ->createStackTrace(stackTrace)
     365         180 :                                           ->buildInspectorObjectImpl());
     366             :   }
     367        1590 :   if (!exception.IsEmpty()) {
     368        1590 :     std::unique_ptr<protocol::Runtime::RemoteObject> wrapped;
     369             :     Response response =
     370             :         wrapObject(exception, objectGroup, false /* forceValueType */,
     371        1590 :                    generatePreview && !exception->IsNativeError(), &wrapped);
     372        1590 :     if (!response.isSuccess()) return response;
     373             :     exceptionDetails->setException(std::move(wrapped));
     374             :   }
     375             :   *result = std::move(exceptionDetails);
     376        1590 :   return Response::OK();
     377             : }
     378             : 
     379       18985 : Response InjectedScript::wrapEvaluateResult(
     380             :     v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch& tryCatch,
     381             :     const String16& objectGroup, bool returnByValue, bool generatePreview,
     382             :     std::unique_ptr<protocol::Runtime::RemoteObject>* result,
     383             :     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
     384             :   v8::Local<v8::Value> resultValue;
     385       18985 :   if (!tryCatch.HasCaught()) {
     386       17410 :     if (!maybeResultValue.ToLocal(&resultValue))
     387           0 :       return Response::InternalError();
     388             :     Response response = wrapObject(resultValue, objectGroup, returnByValue,
     389       17410 :                                    generatePreview, result);
     390       17410 :     if (!response.isSuccess()) return response;
     391       34820 :     if (objectGroup == "console")
     392         198 :       m_lastEvaluationResult.Reset(m_context->isolate(), resultValue);
     393             :   } else {
     394        1575 :     v8::Local<v8::Value> exception = tryCatch.Exception();
     395             :     Response response =
     396             :         wrapObject(exception, objectGroup, false,
     397        1575 :                    generatePreview && !exception->IsNativeError(), result);
     398        1575 :     if (!response.isSuccess()) return response;
     399             :     // We send exception in result for compatibility reasons, even though it's
     400             :     // accessible through exceptionDetails.exception.
     401        3120 :     response = createExceptionDetails(tryCatch, objectGroup, generatePreview,
     402             :                                       exceptionDetails);
     403        1560 :     if (!response.isSuccess()) return response;
     404             :   }
     405       18970 :   return Response::OK();
     406             : }
     407             : 
     408         408 : v8::Local<v8::Object> InjectedScript::commandLineAPI() {
     409         408 :   if (m_commandLineAPI.IsEmpty()) {
     410             :     m_commandLineAPI.Reset(
     411             :         m_context->isolate(),
     412             :         m_context->inspector()->console()->createCommandLineAPI(
     413         108 :             m_context->context()));
     414             :   }
     415         816 :   return m_commandLineAPI.Get(m_context->isolate());
     416             : }
     417             : 
     418      379875 : InjectedScript::Scope::Scope(V8InspectorImpl* inspector, int contextGroupId)
     419             :     : m_inspector(inspector),
     420             :       m_contextGroupId(contextGroupId),
     421             :       m_injectedScript(nullptr),
     422             :       m_handleScope(inspector->isolate()),
     423             :       m_tryCatch(inspector->isolate()),
     424             :       m_ignoreExceptionsAndMuteConsole(false),
     425             :       m_previousPauseOnExceptionsState(v8::debug::NoBreakOnException),
     426      506500 :       m_userGesture(false) {}
     427             : 
     428      146360 : Response InjectedScript::Scope::initialize() {
     429      146360 :   cleanup();
     430             :   // TODO(dgozman): what if we reattach to the same context group during
     431             :   // evaluate? Introduce a session id?
     432             :   V8InspectorSessionImpl* session =
     433      146360 :       m_inspector->sessionForContextGroup(m_contextGroupId);
     434      146360 :   if (!session) return Response::InternalError();
     435      146354 :   Response response = findInjectedScript(session);
     436      146354 :   if (!response.isSuccess()) return response;
     437      146342 :   m_context = m_injectedScript->context()->context();
     438      146342 :   m_context->Enter();
     439      146342 :   return Response::OK();
     440             : }
     441             : 
     442         408 : void InjectedScript::Scope::installCommandLineAPI() {
     443             :   DCHECK(m_injectedScript && !m_context.IsEmpty() &&
     444             :          !m_commandLineAPIScope.get());
     445             :   m_commandLineAPIScope.reset(new V8Console::CommandLineAPIScope(
     446        1224 :       m_context, m_injectedScript->commandLineAPI(), m_context->Global()));
     447         408 : }
     448             : 
     449      106254 : void InjectedScript::Scope::ignoreExceptionsAndMuteConsole() {
     450             :   DCHECK(!m_ignoreExceptionsAndMuteConsole);
     451      106254 :   m_ignoreExceptionsAndMuteConsole = true;
     452      106254 :   m_inspector->client()->muteMetrics(m_contextGroupId);
     453      106254 :   m_inspector->muteExceptions(m_contextGroupId);
     454             :   m_previousPauseOnExceptionsState =
     455      106254 :       setPauseOnExceptionsState(v8::debug::NoBreakOnException);
     456      106254 : }
     457             : 
     458      212508 : v8::debug::ExceptionBreakState InjectedScript::Scope::setPauseOnExceptionsState(
     459             :     v8::debug::ExceptionBreakState newState) {
     460      425016 :   if (!m_inspector->debugger()->enabled()) return newState;
     461             :   v8::debug::ExceptionBreakState presentState =
     462      423816 :       m_inspector->debugger()->getPauseOnExceptionsState();
     463      211908 :   if (presentState != newState)
     464         864 :     m_inspector->debugger()->setPauseOnExceptionsState(newState);
     465      211908 :   return presentState;
     466             : }
     467             : 
     468           0 : void InjectedScript::Scope::pretendUserGesture() {
     469             :   DCHECK(!m_userGesture);
     470           0 :   m_userGesture = true;
     471           0 :   m_inspector->client()->beginUserGesture();
     472           0 : }
     473             : 
     474      272985 : void InjectedScript::Scope::cleanup() {
     475             :   m_commandLineAPIScope.reset();
     476      272985 :   if (!m_context.IsEmpty()) {
     477      146342 :     m_context->Exit();
     478             :     m_context.Clear();
     479             :   }
     480      272985 : }
     481             : 
     482      253250 : InjectedScript::Scope::~Scope() {
     483      126625 :   if (m_ignoreExceptionsAndMuteConsole) {
     484      106254 :     setPauseOnExceptionsState(m_previousPauseOnExceptionsState);
     485      106254 :     m_inspector->client()->unmuteMetrics(m_contextGroupId);
     486      106254 :     m_inspector->unmuteExceptions(m_contextGroupId);
     487             :   }
     488      126625 :   if (m_userGesture) m_inspector->client()->endUserGesture();
     489      126625 :   cleanup();
     490      126625 : }
     491             : 
     492        5435 : InjectedScript::ContextScope::ContextScope(V8InspectorImpl* inspector,
     493             :                                            int contextGroupId,
     494             :                                            int executionContextId)
     495             :     : InjectedScript::Scope(inspector, contextGroupId),
     496        5435 :       m_executionContextId(executionContextId) {}
     497             : 
     498        5435 : InjectedScript::ContextScope::~ContextScope() {}
     499             : 
     500       10264 : Response InjectedScript::ContextScope::findInjectedScript(
     501             :     V8InspectorSessionImpl* session) {
     502       10264 :   return session->findInjectedScript(m_executionContextId, m_injectedScript);
     503             : }
     504             : 
     505      106632 : InjectedScript::ObjectScope::ObjectScope(V8InspectorImpl* inspector,
     506             :                                          int contextGroupId,
     507             :                                          const String16& remoteObjectId)
     508             :     : InjectedScript::Scope(inspector, contextGroupId),
     509      213264 :       m_remoteObjectId(remoteObjectId) {}
     510             : 
     511      213264 : InjectedScript::ObjectScope::~ObjectScope() {}
     512             : 
     513      107298 : Response InjectedScript::ObjectScope::findInjectedScript(
     514             :     V8InspectorSessionImpl* session) {
     515      107298 :   std::unique_ptr<RemoteObjectId> remoteId;
     516      107298 :   Response response = RemoteObjectId::parse(m_remoteObjectId, &remoteId);
     517      107298 :   if (!response.isSuccess()) return response;
     518      107298 :   InjectedScript* injectedScript = nullptr;
     519      214596 :   response = session->findInjectedScript(remoteId.get(), injectedScript);
     520      107298 :   if (!response.isSuccess()) return response;
     521      214596 :   m_objectGroupName = injectedScript->objectGroupName(*remoteId);
     522      321894 :   response = injectedScript->findObject(*remoteId, &m_object);
     523      107298 :   if (!response.isSuccess()) return response;
     524      107298 :   m_injectedScript = injectedScript;
     525      107298 :   return Response::OK();
     526             : }
     527             : 
     528       14558 : InjectedScript::CallFrameScope::CallFrameScope(V8InspectorImpl* inspector,
     529             :                                                int contextGroupId,
     530             :                                                const String16& remoteObjectId)
     531             :     : InjectedScript::Scope(inspector, contextGroupId),
     532       29116 :       m_remoteCallFrameId(remoteObjectId) {}
     533             : 
     534       29116 : InjectedScript::CallFrameScope::~CallFrameScope() {}
     535             : 
     536       28792 : Response InjectedScript::CallFrameScope::findInjectedScript(
     537             :     V8InspectorSessionImpl* session) {
     538       28792 :   std::unique_ptr<RemoteCallFrameId> remoteId;
     539       28792 :   Response response = RemoteCallFrameId::parse(m_remoteCallFrameId, &remoteId);
     540       28792 :   if (!response.isSuccess()) return response;
     541       28792 :   m_frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
     542       28792 :   return session->findInjectedScript(remoteId.get(), m_injectedScript);
     543             : }
     544             : 
     545             : }  // namespace v8_inspector

Generated by: LCOV version 1.10