[DevTools] Follow up with cleanups for InjectedScript::Scope.

third_party/WebKit/Source/platform/v8_inspector/InjectedScript.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 103 matching lines @@
     : m_context(context)
     , m_value(context->isolate(), object)
     , m_native(injectedScriptNative)
 {
 }
 
 InjectedScript::~InjectedScript()
 {
 }
 
-v8::Isolate* InjectedScript::isolate() const
-{
-    return m_context->isolate();
-}
-
 void InjectedScript::getProperties(ErrorString* errorString, v8::Local<v8::Object> object, const String16& groupName, bool ownProperties, bool accessorPropertiesOnly, bool generatePreview, OwnPtr<Array<PropertyDescriptor>>* properties, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
-    v8::HandleScope handles(isolate());
+    v8::HandleScope handles(m_context->isolate());
     V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "getProperties");
     function.appendArgument(object);
     function.appendArgument(groupName);
     function.appendArgument(ownProperties);
     function.appendArgument(accessorPropertiesOnly);
     function.appendArgument(generatePreview);
 
-    v8::TryCatch tryCatch(isolate());
+    v8::TryCatch tryCatch(m_context->isolate());
     v8::Local<v8::Value> resultValue = function.callWithoutExceptionHandling();
     if (tryCatch.HasCaught()) {
         *exceptionDetails = createExceptionDetails(tryCatch.Message());
         // FIXME: make properties optional
         *properties = Array<PropertyDescriptor>::create();
         return;
     }
 
     OwnPtr<protocol::Value> protocolValue = toProtocolValue(function.context(), resultValue);
     if (hasInternalError(errorString, !protocolValue))
@@ skipping 13 matching lines @@
     if (!object)
         return;
     int boundId = 0;
     if (!object->getNumber("id", &boundId))
         return;
     m_native->unbind(boundId);
 }
 
 PassOwnPtr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(ErrorString* errorString, v8::Local<v8::Value> value, const String16& groupName, bool forceValueType, bool generatePreview) const
 {
-    v8::HandleScope handles(isolate());
+    v8::HandleScope handles(m_context->isolate());
     V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "wrapObject");
     v8::Local<v8::Value> wrappedObject;
     if (!wrapValue(errorString, value, groupName, forceValueType, generatePreview).ToLocal(&wrappedObject))
         return nullptr;
     protocol::ErrorSupport errors;
     OwnPtr<protocol::Runtime::RemoteObject> remoteObject = protocol::Runtime::RemoteObject::parse(toProtocolValue(m_context->context(), wrappedObject).get(), &errors);
     if (!remoteObject)
         *errorString = "Object has too long reference chain";
     return remoteObject.release();
 }
@@ skipping 49 matching lines @@
     function.appendArgument(generatePreview);
     bool hadException = false;
     v8::Local<v8::Value> r = function.call(hadException);
     if (hasInternalError(errorString, hadException || r.IsEmpty()))
         return v8::MaybeLocal<v8::Value>();
     return r;
 }
 
 PassOwnPtr<protocol::Runtime::RemoteObject> InjectedScript::wrapTable(v8::Local<v8::Value> table, v8::Local<v8::Value> columns) const
 {
-    v8::HandleScope handles(isolate());
+    v8::HandleScope handles(m_context->isolate());
     V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "wrapTable");
     function.appendArgument(canAccessInspectedWindow());
     function.appendArgument(table);
     if (columns.IsEmpty())
         function.appendArgument(false);
     else
         function.appendArgument(columns);
     bool hadException = false;
     v8::Local<v8::Value>  r = function.call(hadException);
     if (hadException)
@@ skipping 10 matching lines @@
     return !outObject->IsEmpty();
 }
 
 String16 InjectedScript::objectGroupName(const RemoteObjectId& objectId) const
 {
     return m_native->groupName(objectId.id());
 }
 
 void InjectedScript::releaseObjectGroup(const String16& objectGroup)
 {
-    v8::HandleScope handles(isolate());
+    v8::HandleScope handles(m_context->isolate());
     m_native->releaseObjectGroup(objectGroup);
     if (objectGroup == "console") {
         V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "clearLastEvaluationResult");
         bool hadException = false;
         function.call(hadException);
         ASSERT(!hadException);
     }
 }
 
 void InjectedScript::setCustomObjectFormatterEnabled(bool enabled)
 {
-    v8::HandleScope handles(isolate());
+    v8::HandleScope handles(m_context->isolate());
     V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "setCustomObjectFormatterEnabled");
     function.appendArgument(enabled);
     bool hadException = false;
     function.call(hadException);
     ASSERT(!hadException);
 }
 
 bool InjectedScript::canAccessInspectedWindow() const
 {
-    v8::Local<v8::Context> callingContext = isolate()->GetCallingContext();
+    v8::Local<v8::Context> callingContext = m_context->isolate()->GetCallingContext();
     if (callingContext.IsEmpty())
         return true;
     return m_context->debugger()->client()->callingContextCanAccessContext(callingContext, m_context->context());
 }
 
 v8::Local<v8::Value> InjectedScript::v8Value() const
 {
-    return m_value.Get(isolate());
+    return m_value.Get(m_context->isolate());
 }
 
 bool InjectedScript::setLastEvaluationResult(ErrorString* errorString, v8::Local<v8::Value> value)
 {
     V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "setLastEvaluationResult");
     function.appendArgument(value);
     bool hadException = false;
     function.call(hadException, false);
     return !hasInternalError(errorString, hadException);
 }
@@ skipping 11 matching lines @@
         v8::Local<v8::Value> object;
         if (!findObject(errorString, *remoteObjectId, &object))
             return v8::MaybeLocal<v8::Value>();
         return object;
     }
     if (callArgument->hasValue()) {
         String16 value = callArgument->getValue(nullptr)->toJSONString();
         if (callArgument->getType(String16()) == "number")
             value = "Number(" + value + ")";
         v8::Local<v8::Value> object;
-        if (!m_context->debugger()->compileAndRunInternalScript(m_context->context(), toV8String(isolate(), value)).ToLocal(&object)) {
+        if (!m_context->debugger()->compileAndRunInternalScript(m_context->context(), toV8String(m_context->isolate(), value)).ToLocal(&object)) {
             *errorString = "Couldn't parse value object in call argument";
             return v8::MaybeLocal<v8::Value>();
         }
         return object;
     }
-    return v8::Undefined(isolate());
-}
-
-v8::MaybeLocal<v8::Object> InjectedScript::commandLineAPI(ErrorString* errorString) const
-{
-    V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "commandLineAPI");
-    return callFunctionReturnObject(errorString, function);
-}
-
-v8::MaybeLocal<v8::Object> InjectedScript::remoteObjectAPI(ErrorString* errorString, const String16& groupName) const
-{
-    V8FunctionCall function(m_context->debugger(), m_context->context(), v8Value(), "remoteObjectAPI");
-    function.appendArgument(groupName);
-    return callFunctionReturnObject(errorString, function);
-}
-
-v8::MaybeLocal<v8::Object> InjectedScript::callFunctionReturnObject(ErrorString* errorString, V8FunctionCall& function) const
-{
-    bool hadException = false;
-    v8::Local<v8::Value> result = function.call(hadException, false);
-    v8::Local<v8::Object> resultObject;
-    if (hasInternalError(errorString, hadException || result.IsEmpty() || !result->ToObject(m_context->context()).ToLocal(&resultObject)))
-        return v8::MaybeLocal<v8::Object>();
-    return resultObject;
+    return v8::Undefined(m_context->isolate());
 }
 
 PassOwnPtr<protocol::Runtime::ExceptionDetails> InjectedScript::createExceptionDetails(v8::Local<v8::Message> message)
 {
     OwnPtr<protocol::Runtime::ExceptionDetails> exceptionDetailsObject = protocol::Runtime::ExceptionDetails::create().setText(toProtocolString(message->Get())).build();
     exceptionDetailsObject->setUrl(toProtocolStringWithTypeCheck(message->GetScriptResourceName()));
     exceptionDetailsObject->setScriptId(String16::number(message->GetScriptOrigin().ScriptID()->Value()));
 
     v8::Maybe<int> lineNumber = message->GetLineNumber(m_context->context());
     if (lineNumber.IsJust())
@@ skipping 35 matching lines @@
     }
 }
 
 InjectedScript::Scope::Scope(ErrorString* errorString, V8DebuggerImpl* debugger, int contextGroupId)
     : m_errorString(errorString)
     , m_debugger(debugger)
     , m_contextGroupId(contextGroupId)
     , m_injectedScript(nullptr)
     , m_handleScope(debugger->isolate())
     , m_tryCatch(debugger->isolate())
+    , m_ignoreExceptionsAndMuteConsole(false)
+    , m_previousPauseOnExceptionsState(V8DebuggerImpl::DontPauseOnExceptions)
 {
 }
 
 bool InjectedScript::Scope::initialize()
 {
     cleanup();
     // TODO(dgozman): what if we reattach to the same context group during evaluate? Introduce a session id?
     V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId);
     if (!session) {
         *m_errorString = "Internal error";
         return false;
     }
     findInjectedScript(session);
     if (!m_injectedScript)
         return false;
     m_context = m_injectedScript->context()->context();
     m_context->Enter();
     return true;
 }
 
-void InjectedScript::Scope::installGlobalObjectExtension(v8::MaybeLocal<v8::Object> extension)
+bool InjectedScript::Scope::installCommandLineAPI()
 {
-    v8::Local<v8::Object> extensionObject;
-    if (m_context.IsEmpty() || !extension.ToLocal(&extensionObject))
-        return;
+    ASSERT(m_injectedScript && !m_context.IsEmpty());
+    V8FunctionCall function(m_debugger, m_context, m_injectedScript->v8Value(), "commandLineAPI");
+    return installGlobalObjectExtension(function);
+}
 
+bool InjectedScript::Scope::installRemoteObjectAPI(const String16& objectGroupName)
+{
+    ASSERT(m_injectedScript && !m_context.IsEmpty());
+    V8FunctionCall function(m_debugger, m_context, m_injectedScript->v8Value(), "remoteObjectAPI");
+    function.appendArgument(objectGroupName);
+    return installGlobalObjectExtension(function);
+}
+
+bool InjectedScript::Scope::installGlobalObjectExtension(V8FunctionCall& function)
+{
+    bool hadException = false;
+    v8::Local<v8::Value> extension = function.call(hadException, false);
+    if (hadException || extension.IsEmpty()) {
+        *m_errorString = "Internal error";
+        return false;
+    }
+
+    ASSERT(m_global.IsEmpty());
     m_extensionSymbol = V8Debugger::scopeExtensionSymbol(m_debugger->isolate());
     v8::Local<v8::Object> global = m_context->Global();
-    if (global->Set(m_context, m_extensionSymbol, extensionObject).FromMaybe(false))
-        m_global = global;
+    if (!global->Set(m_context, m_extensionSymbol, extension).FromMaybe(false)) {
+        *m_errorString = "Internal error";
+        return false;
+    }
+
+    m_global = global;
+    return true;
+}
+
+void InjectedScript::Scope::ignoreExceptionsAndMuteConsole()
+{
+    ASSERT(!m_ignoreExceptionsAndMuteConsole);
+    m_ignoreExceptionsAndMuteConsole = true;
+    m_debugger->client()->muteConsole();
+    m_previousPauseOnExceptionsState = setPauseOnExceptionsState(V8DebuggerImpl::DontPauseOnExceptions);
+}
+
+V8DebuggerImpl::PauseOnExceptionsState InjectedScript::Scope::setPauseOnExceptionsState(V8DebuggerImpl::PauseOnExceptionsState newState)
+{
+    if (!m_debugger->enabled())
+        return newState;
+    V8DebuggerImpl::PauseOnExceptionsState presentState = m_debugger->getPauseOnExceptionsState();
+    if (presentState != newState)
+        m_debugger->setPauseOnExceptionsState(newState);
+    return presentState;
 }
 
 void InjectedScript::Scope::cleanup()
 {
     v8::Local<v8::Object> global;
     if (m_global.ToLocal(&global)) {
         ASSERT(!m_context.IsEmpty());
         global->Delete(m_context, m_extensionSymbol);
         m_global = v8::MaybeLocal<v8::Object>();
     }
     if (!m_context.IsEmpty()) {
         m_context->Exit();
         m_context.Clear();
     }
 }
 
 InjectedScript::Scope::~Scope()
 {
+    if (m_ignoreExceptionsAndMuteConsole) {
+        setPauseOnExceptionsState(m_previousPauseOnExceptionsState);
+        m_debugger->client()->unmuteConsole();
+    }
     cleanup();
 }
 
 InjectedScript::ContextScope::ContextScope(ErrorString* errorString, V8DebuggerImpl* debugger, int contextGroupId, int executionContextId)
     : InjectedScript::Scope(errorString, debugger, contextGroupId)
     , m_executionContextId(executionContextId)
 {
 }
 
 InjectedScript::ContextScope::~ContextScope()
@@ skipping 42 matching lines @@
 void InjectedScript::CallFrameScope::findInjectedScript(V8InspectorSessionImpl* session)
 {
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(m_errorString, m_remoteCallFrameId);
     if (!remoteId)
         return;
     m_frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
     m_injectedScript = session->findInjectedScript(m_errorString, remoteId.get());
 }
 
 } // namespace blink