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 43using Inspector::TypeBuilder::Array; 44 45namespace Inspector { 46 47InjectedScript::InjectedScript() 48 : InjectedScriptBase(ASCIILiteral("InjectedScript")) 49{ 50} 51 52InjectedScript::InjectedScript(Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment) 53 : InjectedScriptBase(ASCIILiteral("InjectedScript"), injectedScriptObject, environment) 54{ 55} 56 57InjectedScript::~InjectedScript() 58{ 59} 60 61void 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 72void 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 83void 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 96void 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 112void 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 128void 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 145PassRefPtr<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 161PassRefPtr<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 179PassRefPtr<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 199Deprecated::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 212void 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 221void 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 229void 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) 243