inspector/InjectedScript.cpp

   1 /*
   2  * Copyright (C) 2013 Apple Inc. All rights reserved.
   3  * Copyright (C) 2012 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  *     * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *     * Neither the name of Google Inc. nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "config.h"
  33 #include "InjectedScript.h"
  34
  35 #if ENABLE(INSPECTOR)
  36
  37 #include "InspectorValues.h"
  38 #include "JSCInlines.h"
  39 #include "ScriptFunctionCall.h"
  40 #include "ScriptObject.h"
  41 #include <wtf/text/WTFString.h>
  42
  43 using Inspector::TypeBuilder::Array;
  44
  45 namespace Inspector {
  46
  47 InjectedScript::InjectedScript()
  48     : InjectedScriptBase(ASCIILiteral("InjectedScript"))
  49 {
  50 }
  51
  52 InjectedScript::InjectedScript(Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment)
  53     : InjectedScriptBase(ASCIILiteral("InjectedScript"), injectedScriptObject, environment)
  54 {
  55 }
  56
  57 InjectedScript::~InjectedScript()
  58 {
  59 }
  60
  61 void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<Inspector::TypeBuilder::Runtime::RemoteObject>* result, Inspector::TypeBuilder::OptOutput<bool>* wasThrown)
  62 {
  63     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluate"), inspectorEnvironment()->functionCallHandler());
  64     function.appendArgument(expression);
  65     function.appendArgument(objectGroup);
  66     function.appendArgument(includeCommandLineAPI);
  67     function.appendArgument(returnByValue);
  68     function.appendArgument(generatePreview);
  69     makeEvalCall(errorString, function, result, wasThrown);
  70 }
  71
  72 void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr<Inspector::TypeBuilder::Runtime::RemoteObject>* result, Inspector::TypeBuilder::OptOutput<bool>* wasThrown)
  73 {
  74     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("callFunctionOn"), inspectorEnvironment()->functionCallHandler());
  75     function.appendArgument(objectId);
  76     function.appendArgument(expression);
  77     function.appendArgument(arguments);
  78     function.appendArgument(returnByValue);
  79     function.appendArgument(generatePreview);
  80     makeEvalCall(errorString, function, result, wasThrown);
  81 }
  82
  83 void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, const Deprecated::ScriptValue& callFrames, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<Inspector::TypeBuilder::Runtime::RemoteObject>* result, Inspector::TypeBuilder::OptOutput<bool>* wasThrown)
  84 {
  85     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluateOnCallFrame"), inspectorEnvironment()->functionCallHandler());
  86     function.appendArgument(callFrames);
  87     function.appendArgument(callFrameId);
  88     function.appendArgument(expression);
  89     function.appendArgument(objectGroup);
  90     function.appendArgument(includeCommandLineAPI);
  91     function.appendArgument(returnByValue);
  92     function.appendArgument(generatePreview);
  93     makeEvalCall(errorString, function, result, wasThrown);
  94 }
  95
  96 void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<Inspector::TypeBuilder::Debugger::FunctionDetails>* result)
  97 {
  98     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getFunctionDetails"), inspectorEnvironment()->functionCallHandler());
  99     function.appendArgument(functionId);
 100
 101     RefPtr<InspectorValue> resultValue;
 102     makeCall(function, &resultValue);
 103     if (!resultValue || resultValue->type() != InspectorValue::TypeObject) {
 104         if (!resultValue->asString(errorString))
 105             *errorString = ASCIILiteral("Internal error");
 106         return;
 107     }
 108
 109     *result = Inspector::TypeBuilder::Debugger::FunctionDetails::runtimeCast(resultValue);
 110 }
 111
 112 void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, RefPtr<Array<Inspector::TypeBuilder::Runtime::PropertyDescriptor>>* properties)
 113 {
 114     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getProperties"), inspectorEnvironment()->functionCallHandler());
 115     function.appendArgument(objectId);
 116     function.appendArgument(ownProperties);
 117
 118     RefPtr<InspectorValue> result;
 119     makeCall(function, &result);
 120     if (!result || result->type() != InspectorValue::TypeArray) {
 121         *errorString = ASCIILiteral("Internal error");
 122         return;
 123     }
 124
 125     *properties = Array<Inspector::TypeBuilder::Runtime::PropertyDescriptor>::runtimeCast(result);
 126 }
 127
 128 void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, RefPtr<Array<Inspector::TypeBuilder::Runtime::InternalPropertyDescriptor>>* properties)
 129 {
 130     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getInternalProperties"), inspectorEnvironment()->functionCallHandler());
 131     function.appendArgument(objectId);
 132
 133     RefPtr<InspectorValue> result;
 134     makeCall(function, &result);
 135     if (!result || result->type() != InspectorValue::TypeArray) {
 136         *errorString = ASCIILiteral("Internal error");
 137         return;
 138     }
 139
 140     RefPtr<Array<Inspector::TypeBuilder::Runtime::InternalPropertyDescriptor>> array = Array<Inspector::TypeBuilder::Runtime::InternalPropertyDescriptor>::runtimeCast(result);
 141     if (array->length() > 0)
 142         *properties = array;
 143 }
 144
 145 PassRefPtr<Array<Inspector::TypeBuilder::Debugger::CallFrame>> InjectedScript::wrapCallFrames(const Deprecated::ScriptValue& callFrames)
 146 {
 147     ASSERT(!hasNoValue());
 148     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("wrapCallFrames"), inspectorEnvironment()->functionCallHandler());
 149     function.appendArgument(callFrames);
 150
 151     bool hadException = false;
 152     Deprecated::ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException);
 153     ASSERT(!hadException);
 154     RefPtr<InspectorValue> result = callFramesValue.toInspectorValue(scriptState());
 155     if (result->type() == InspectorValue::TypeArray)
 156         return Array<Inspector::TypeBuilder::Debugger::CallFrame>::runtimeCast(result);
 157
 158     return Array<Inspector::TypeBuilder::Debugger::CallFrame>::create();
 159 }
 160
 161 PassRefPtr<Inspector::TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapObject(const Deprecated::ScriptValue& value, const String& groupName, bool generatePreview) const
 162 {
 163     ASSERT(!hasNoValue());
 164     Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapObject"), inspectorEnvironment()->functionCallHandler());
 165     wrapFunction.appendArgument(value);
 166     wrapFunction.appendArgument(groupName);
 167     wrapFunction.appendArgument(hasAccessToInspectedScriptState());
 168     wrapFunction.appendArgument(generatePreview);
 169
 170     bool hadException = false;
 171     Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
 172     if (hadException)
 173         return nullptr;
 174
 175     RefPtr<InspectorObject> rawResult = r.toInspectorValue(scriptState())->asObject();
 176     return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
 177 }
 178
 179 PassRefPtr<Inspector::TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapTable(const Deprecated::ScriptValue& table, const Deprecated::ScriptValue& columns) const
 180 {
 181     ASSERT(!hasNoValue());
 182     Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapTable"), inspectorEnvironment()->functionCallHandler());
 183     wrapFunction.appendArgument(hasAccessToInspectedScriptState());
 184     wrapFunction.appendArgument(table);
 185     if (columns.hasNoValue())
 186         wrapFunction.appendArgument(false);
 187     else
 188         wrapFunction.appendArgument(columns);
 189
 190     bool hadException = false;
 191     Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
 192     if (hadException)
 193         return nullptr;
 194
 195     RefPtr<InspectorObject> rawResult = r.toInspectorValue(scriptState())->asObject();
 196     return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
 197 }
 198
 199 Deprecated::ScriptValue InjectedScript::findObjectById(const String& objectId) const
 200 {
 201     ASSERT(!hasNoValue());
 202     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("findObjectById"), inspectorEnvironment()->functionCallHandler());
 203     function.appendArgument(objectId);
 204
 205     bool hadException = false;
 206     Deprecated::ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
 207     ASSERT(!hadException);
 208
 209     return resultValue;
 210 }
 211
 212 void InjectedScript::inspectObject(Deprecated::ScriptValue value)
 213 {
 214     ASSERT(!hasNoValue());
 215     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("inspectObject"), inspectorEnvironment()->functionCallHandler());
 216     function.appendArgument(value);
 217     RefPtr<InspectorValue> result;
 218     makeCall(function, &result);
 219 }
 220
 221 void InjectedScript::releaseObject(const String& objectId)
 222 {
 223     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("releaseObject"), inspectorEnvironment()->functionCallHandler());
 224     function.appendArgument(objectId);
 225     RefPtr<InspectorValue> result;
 226     makeCall(function, &result);
 227 }
 228
 229 void InjectedScript::releaseObjectGroup(const String& objectGroup)
 230 {
 231     ASSERT(!hasNoValue());
 232     Deprecated::ScriptFunctionCall releaseFunction(injectedScriptObject(), ASCIILiteral("releaseObjectGroup"), inspectorEnvironment()->functionCallHandler());
 233     releaseFunction.appendArgument(objectGroup);
 234
 235     bool hadException = false;
 236     callFunctionWithEvalEnabled(releaseFunction, hadException);
 237     ASSERT(!hadException);
 238 }
 239
 240 } // namespace Inspector
 241
 242 #endif // ENABLE(INSPECTOR)