Remove V8RecrusionScope, cleanup call sites.

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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/v8_inspector/InjectedScript.h"
 
 #include "platform/inspector_protocol/Parser.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
+#include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8FunctionCall.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "platform/v8_inspector/public/V8ToProtocolValue.h"
 #include "wtf/text/WTFString.h"
 
 using blink::protocol::Array;
 using blink::protocol::Debugger::CallFrame;
 using blink::protocol::Debugger::CollectionEntry;
@@ skipping 60 matching lines @@
     if (originScriptId)
         exceptionDetails->setScriptId(String::number(originScriptId));
     return exceptionDetails.release();
 }
 
 static void weakCallback(const v8::WeakCallbackInfo<InjectedScript>& data)
 {
     data.GetParameter()->dispose();
 }
 
-InjectedScript::InjectedScript(InjectedScriptManager* manager, v8::Local<v8::Context> context, v8::Local<v8::Object> object, V8DebuggerClient* client, PassOwnPtr<InjectedScriptNative> injectedScriptNative, int contextId)
+InjectedScript::InjectedScript(InjectedScriptManager* manager, v8::Local<v8::Context> context, v8::Local<v8::Object> object, PassOwnPtr<InjectedScriptNative> injectedScriptNative, int contextId)
     : m_manager(manager)
     , m_isolate(context->GetIsolate())
     , m_context(m_isolate, context)
     , m_value(m_isolate, object)
-    , m_client(client)
     , m_native(injectedScriptNative)
     , m_contextId(contextId)
 {
     m_context.SetWeak(this, &weakCallback, v8::WeakCallbackType::kParameter);
 }
 
 InjectedScript::~InjectedScript()
 {
 }
 
 void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "evaluate");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "evaluate");
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     *result = makeEvalCall(errorString, function, wasThrown, exceptionDetails);
 }
 
 void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, Maybe<bool>* wasThrown)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "callFunctionOn");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "callFunctionOn");
     function.appendArgument(objectId);
     function.appendArgument(expression);
     function.appendArgument(arguments);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     *result = makeEvalCall(errorString, function, wasThrown);
 }
 
 void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "evaluateOnCallFrame");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "evaluateOnCallFrame");
     function.appendArgument(callFrames);
     function.appendArgument(callFrameId);
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     *result = makeEvalCall(errorString, function, wasThrown, exceptionDetails);
 }
 
 void InjectedScript::restartFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "restartFrame");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "restartFrame");
     function.appendArgument(callFrames);
     function.appendArgument(callFrameId);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     if (resultValue) {
         if (resultValue->type() == protocol::Value::TypeString) {
             resultValue->asString(errorString);
         } else {
             bool value;
             ASSERT_UNUSED(value, resultValue->asBoolean(&value) && value);
         }
         return;
     }
     *errorString = "Internal error";
 }
 
 void InjectedScript::getStepInPositions(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId, Maybe<Array<protocol::Debugger::Location>>* positions)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "getStepInPositions");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getStepInPositions");
     function.appendArgument(callFrames);
     function.appendArgument(callFrameId);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     if (resultValue) {
         if (resultValue->type() == protocol::Value::TypeString) {
             resultValue->asString(errorString);
             return;
         }
         if (resultValue->type() == protocol::Value::TypeArray) {
             protocol::ErrorSupport errors(errorString);
             *positions = Array<protocol::Debugger::Location>::parse(resultValue.get(), &errors);
             return;
         }
     }
     *errorString = "Internal error";
 }
 
 void InjectedScript::setVariableValue(ErrorString* errorString,
     v8::Local<v8::Object> callFrames,
     const protocol::Maybe<String>& callFrameIdOpt,
     const protocol::Maybe<String>&  functionObjectIdOpt,
     int scopeNumber,
     const String& variableName,
     const String& newValueStr)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "setVariableValue");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "setVariableValue");
     if (callFrameIdOpt.isJust()) {
         function.appendArgument(callFrames);
         function.appendArgument(callFrameIdOpt.fromJust());
     } else {
         function.appendArgument(false);
         function.appendArgument(false);
     }
     if (functionObjectIdOpt.isJust())
         function.appendArgument(functionObjectIdOpt.fromJust());
     else
         function.appendArgument(false);
     function.appendArgument(scopeNumber);
     function.appendArgument(variableName);
     function.appendArgument(newValueStr);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     if (!resultValue) {
         *errorString = "Internal error";
         return;
     }
     if (resultValue->type() == protocol::Value::TypeString) {
         resultValue->asString(errorString);
         return;
     }
     // Normal return.
 }
 
 void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, OwnPtr<FunctionDetails>* result)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "getFunctionDetails");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getFunctionDetails");
     function.appendArgument(functionId);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     protocol::ErrorSupport errors(errorString);
     *result = FunctionDetails::parse(resultValue.get(), &errors);
 }
 
 void InjectedScript::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, OwnPtr<GeneratorObjectDetails>* result)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "getGeneratorObjectDetails");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getGeneratorObjectDetails");
     function.appendArgument(objectId);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     protocol::ErrorSupport errors(errorString);
     *result = GeneratorObjectDetails::parse(resultValue.get(), &errors);
 }
 
 void InjectedScript::getCollectionEntries(ErrorString* errorString, const String& objectId, OwnPtr<Array<CollectionEntry>>* result)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "getCollectionEntries");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getCollectionEntries");
     function.appendArgument(objectId);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     protocol::ErrorSupport errors(errorString);
     *result = Array<CollectionEntry>::parse(resultValue.get(), &errors);
 }
 
 void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, bool accessorPropertiesOnly, bool generatePreview, OwnPtr<Array<PropertyDescriptor>>* properties, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "getProperties");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getProperties");
     function.appendArgument(objectId);
     function.appendArgument(ownProperties);
     function.appendArgument(accessorPropertiesOnly);
     function.appendArgument(generatePreview);
 
     OwnPtr<protocol::Value> result = makeCallWithExceptionDetails(function, exceptionDetails);
     if (exceptionDetails->isJust()) {
         // FIXME: make properties optional
         *properties = Array<PropertyDescriptor>::create();
         return;
     }
     protocol::ErrorSupport errors(errorString);
     *properties = Array<PropertyDescriptor>::parse(result.get(), &errors);
 }
 
 void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, Maybe<Array<InternalPropertyDescriptor>>* properties, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "getInternalProperties");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getInternalProperties");
     function.appendArgument(objectId);
 
     OwnPtr<protocol::Value> result = makeCallWithExceptionDetails(function, exceptionDetails);
     if (exceptionDetails->isJust())
         return;
     protocol::ErrorSupport errors(errorString);
     OwnPtr<Array<InternalPropertyDescriptor>> array = Array<InternalPropertyDescriptor>::parse(result.get(), &errors);
     if (!errors.hasErrors() && array->length() > 0)
         *properties = array.release();
 }
 
 void InjectedScript::releaseObject(const String& objectId)
 {
     OwnPtr<protocol::Value> parsedObjectId = protocol::parseJSON(objectId);
     if (!parsedObjectId)
         return;
     protocol::DictionaryValue* object = protocol::DictionaryValue::cast(parsedObjectId.get());
     if (!object)
         return;
     int boundId = 0;
     if (!object->getNumber("id", &boundId))
         return;
     m_native->unbind(boundId);
 }
 
 v8::MaybeLocal<v8::Value> InjectedScript::runCompiledScript(v8::Local<v8::Script> script, bool includeCommandLineAPI)
 {
+    // TODO(dgozman): get rid of this check.
+    if (!m_manager->debugger()->client()->isExecutionAllowed())

[pfeldman, 2016/03/08 20:23:21]

Can you do this within runCompiledScript?

[dgozman, 2016/03/09 22:01:53]

Done.

+        return v8::MaybeLocal<v8::Value>();
+
     v8::Local<v8::Symbol> commandLineAPISymbolValue = V8Debugger::commandLineAPISymbol(m_isolate);
     v8::Local<v8::Object> global = context()->Global();
     if (includeCommandLineAPI) {
-        V8FunctionCall function(m_client, context(), v8Value(), "commandLineAPI");
+        V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "commandLineAPI");
         bool hadException = false;
         v8::Local<v8::Value> commandLineAPI = function.call(hadException, false);
         if (!hadException)
             global->Set(commandLineAPISymbolValue, commandLineAPI);
     }
 
-    v8::MaybeLocal<v8::Value> maybeValue = m_client->runCompiledScript(context(), script);
+    v8::MaybeLocal<v8::Value> maybeValue = m_manager->debugger()->runCompiledScript(context(), script);
     if (includeCommandLineAPI)
         global->Delete(context(), commandLineAPISymbolValue);
 
     return maybeValue;
 }
 
 PassOwnPtr<Array<CallFrame>> InjectedScript::wrapCallFrames(v8::Local<v8::Object> callFrames)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "wrapCallFrames");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "wrapCallFrames");
     function.appendArgument(callFrames);
     bool hadException = false;
     v8::Local<v8::Value> callFramesValue = callFunctionWithEvalEnabled(function, hadException);
     ASSERT(!hadException);
     OwnPtr<protocol::Value> result = toProtocolValue(context(), callFramesValue);
     protocol::ErrorSupport errors;
     if (result && result->type() == protocol::Value::TypeArray)
         return Array<CallFrame>::parse(result.get(), &errors);
     return Array<CallFrame>::create();
 }
 
 PassOwnPtr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(v8::Local<v8::Value> value, const String& groupName, bool generatePreview) const
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "wrapObject");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "wrapObject");
     function.appendArgument(value);
     function.appendArgument(groupName);
     function.appendArgument(canAccessInspectedWindow());
     function.appendArgument(generatePreview);
     bool hadException = false;
     v8::Local<v8::Value> r = callFunctionWithEvalEnabled(function, hadException);
     if (hadException)
         return nullptr;
     protocol::ErrorSupport errors;
     return protocol::Runtime::RemoteObject::parse(toProtocolValue(context(), r).get(), &errors);
 }
 
 PassOwnPtr<protocol::Runtime::RemoteObject> InjectedScript::wrapTable(v8::Local<v8::Value> table, v8::Local<v8::Value> columns) const
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "wrapTable");
+    V8FunctionCall function(m_manager->debugger(), 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 = callFunctionWithEvalEnabled(function, hadException);
     if (hadException)
         return nullptr;
     protocol::ErrorSupport errors;
     return protocol::Runtime::RemoteObject::parse(toProtocolValue(context(), r).get(), &errors);
 }
 
 v8::Local<v8::Value> InjectedScript::findObject(const RemoteObjectId& objectId) const
 {
     return m_native->objectForId(objectId.id());
 }
 
 String InjectedScript::objectGroupName(const RemoteObjectId& objectId) const
 {
     return m_native->groupName(objectId.id());
 }
 
 void InjectedScript::releaseObjectGroup(const String& objectGroup)
 {
     v8::HandleScope handles(m_isolate);
     m_native->releaseObjectGroup(objectGroup);
     if (objectGroup == "console") {
-        V8FunctionCall function(m_client, context(), v8Value(), "clearLastEvaluationResult");
+        V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "clearLastEvaluationResult");
         bool hadException = false;
         callFunctionWithEvalEnabled(function, hadException);
         ASSERT(!hadException);
     }
 }
 
 void InjectedScript::setCustomObjectFormatterEnabled(bool enabled)
 {
     v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_client, context(), v8Value(), "setCustomObjectFormatterEnabled");
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "setCustomObjectFormatterEnabled");
     function.appendArgument(enabled);
     makeCall(function);
 }
 
 bool InjectedScript::canAccessInspectedWindow() const
 {
     v8::Local<v8::Context> callingContext = m_isolate->GetCallingContext();
     if (callingContext.IsEmpty())
         return true;
-    return m_client->callingContextCanAccessContext(callingContext, context());
+    return m_manager->debugger()->client()->callingContextCanAccessContext(callingContext, context());
 }
 
 v8::Local<v8::Context> InjectedScript::context() const
 {
     return m_context.Get(m_isolate);
 }
 
 v8::Local<v8::Value> InjectedScript::v8Value() const
 {
     return m_value.Get(m_isolate);
@@ skipping 86 matching lines @@
     }
     return result.release();
 }
 
 void InjectedScript::dispose()
 {
     m_manager->discardInjectedScript(m_contextId);
 }
 
 } // namespace blink