Changeset 147861 in webkit

Timestamp:

Apr 6, 2013 4:48:05 PM (11 years ago)

Author:

timothy@apple.com

Message:

Remove InjectedScriptHost.evaluateReturnsEvalFunction.

​https://webkit.org/b/114099

Source/WebCore:

• inspector/InjectedScriptHost.h:

(InjectedScriptHost):

• inspector/InjectedScriptHost.idl:
• inspector/InjectedScriptSource.js:

(InjectedScript.prototype._evaluateOn):

LayoutTests:

Reviewed by Joseph Pecoraro.

• inspector/console/command-line-api-expected.txt:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/inspector/console/command-line-api-expected.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/inspector/InjectedScriptHost.h (modified) (1 diff)
• Source/WebCore/inspector/InjectedScriptHost.idl (modified) (1 diff)
• Source/WebCore/inspector/InjectedScriptSource.js (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2013-04-06  Timothy Hatcher  <timothy@apple.com>
+
+        Remove InjectedScriptHost.evaluateReturnsEvalFunction.
+
+        https://webkit.org/b/114099
+
+        Reviewed by Joseph Pecoraro.
+
+        * inspector/console/command-line-api-expected.txt:
+
 2013-04-06  Robert Hogan  <robert@webkit.org>
 

trunk/LayoutTests/inspector/console/command-line-api-expected.txt

@@ -1 @@
-CONSOLE MESSAGE: line 1222: The console function $() has changed from $=getElementById(id) to $=querySelector(selector). You might try $("#%s")
+CONSOLE MESSAGE: line 1200: The console function $() has changed from $=getElementById(id) to $=querySelector(selector). You might try $("#%s")
 Tests that command line api works.
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-04-06  Timothy Hatcher  <timothy@apple.com>
+
+        Remove InjectedScriptHost.evaluateReturnsEvalFunction.
+
+        https://webkit.org/b/114099
+
+        * inspector/InjectedScriptHost.h:
+        (InjectedScriptHost):
+        * inspector/InjectedScriptHost.idl:
+        * inspector/InjectedScriptSource.js:
+        (InjectedScript.prototype._evaluateOn):
+
 2013-04-06  Benjamin Poulain  <bpoulain@apple.com>
 

trunk/Source/WebCore/inspector/InjectedScriptHost.h

@@ -105 +105 @@
     void getEventListenersImpl(Node*, Vector<EventListenerInfo>& listenersArray);
 
-    // FIXME: Remove evaluateReturnsEvalFunction once InjectedScriptHost returns eval in evaluate on V8. https://webkit.org/b/113134
-    bool evaluateReturnsEvalFunction() { return true; }
-
     void clearConsoleMessages();
     void copyText(const String& text);

trunk/Source/WebCore/inspector/InjectedScriptHost.idl

@@ -47 +47 @@
     [Custom] Array getEventListeners(in Node node);
 
-    // FIXME: Remove evaluateReturnsEvalFunction once InjectedScriptHost returns eval in evaluate on V8. https://webkit.org/b/113134
-    readonly attribute boolean evaluateReturnsEvalFunction;
-
     [Custom] readonly attribute any evaluate;
 

trunk/Source/WebCore/inspector/InjectedScriptSource.js

@@ -551 +551 @@
     _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI)
     {
-        if (InjectedScriptHost.evaluateReturnsEvalFunction) {
-            // We can only use this approach if the evaluate function is the true 'eval'. That allows us to use it with
-            // the 'eval' identifier when calling it. Using 'eval' grants access to the local scope of the closure we
-            // create that provides the command line APIs.
-
-            var parameters = [InjectedScriptHost.evaluate, expression];
-            var expressionFunctionBody = "var __originalEval = window.eval; window.eval = __eval; try { return eval(__currentExpression); } finally { window.eval = __originalEval; }";
-
-            if (injectCommandLineAPI) {
-                // To avoid using a 'with' statement (which fails in strict mode and requires injecting the API object)
-                // we instead create a closure where we evaluate the expression. The command line APIs are passed as
-                // parameters to the closure so they are in scope but not injected. This allows the code evaluated in
-                // the console to stay in strict mode (if is was already set), or to get strict mode by prefixing
-                // expressions with 'use strict';.
-
-                var commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
-                var parameterNames = Object.getOwnPropertyNames(commandLineAPI);
-                for (var i = 0; i < parameterNames.length; ++i)
-                    parameters.push(commandLineAPI[parameterNames[i]]);
-
-                var expressionFunctionString = "(function(__eval, __currentExpression, " + parameterNames.join(", ") + ") { " + expressionFunctionBody + " })";
-            } else {
-                // Use a closure in this case too to keep the same behavior of 'var' being captured by the closure instead
-                // of leaking out into the calling scope.
-                var expressionFunctionString = "(function(__eval, __currentExpression) { " + expressionFunctionBody + " })";
-            }
-
-            // Bind 'this' to the function expression using another closure instead of Function.prototype.bind. This ensures things will work if the page replaces bind.
-            var boundExpressionFunctionString = "(function(__function, __thisObject) { return function() { return __function.apply(__thisObject, arguments) }; })(" + expressionFunctionString + ", this)";
-            var expressionFunction = evalFunction.call(object, boundExpressionFunctionString);
-            var result = expressionFunction.apply(null, parameters);
-
-            if (objectGroup === "console")
-                this._lastResult = result;
-
-            return result;
-        }
-
-        // FIXME: This code path should be removed once V8 also returns 'eval' as the evaluate function. See: https://webkit.org/b/113134
-
-        // Only install command line api object for the time of evaluation.
-        // Surround the expression in with statements to inject our command line API so that
-        // the window object properties still take more precedent than our API functions.
-
-        try {
-            if (injectCommandLineAPI && inspectedWindow.console) {
-                inspectedWindow.console._commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
-                expression = "with ((window && window.console && window.console._commandLineAPI) || {}) {\n" + expression + "\n}";
-            }
-            var result = evalFunction.call(object, expression);
-            if (objectGroup === "console")
-                this._lastResult = result;
-            return result;
-        } finally {
-            if (injectCommandLineAPI && inspectedWindow.console)
-                delete inspectedWindow.console._commandLineAPI;
-        }
+        // We can only use this approach if the evaluate function is the true 'eval'. That allows us to use it with
+        // the 'eval' identifier when calling it. Using 'eval' grants access to the local scope of the closure we
+        // create that provides the command line APIs.
+
+        var parameters = [InjectedScriptHost.evaluate, expression];
+        var expressionFunctionBody = "var __originalEval = window.eval; window.eval = __eval; try { return eval(__currentExpression); } finally { window.eval = __originalEval; }";
+
+        if (injectCommandLineAPI) {
+            // To avoid using a 'with' statement (which fails in strict mode and requires injecting the API object)
+            // we instead create a closure where we evaluate the expression. The command line APIs are passed as
+            // parameters to the closure so they are in scope but not injected. This allows the code evaluated in
+            // the console to stay in strict mode (if is was already set), or to get strict mode by prefixing
+            // expressions with 'use strict';.
+
+            var commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
+            var parameterNames = Object.getOwnPropertyNames(commandLineAPI);
+            for (var i = 0; i < parameterNames.length; ++i)
+                parameters.push(commandLineAPI[parameterNames[i]]);
+
+            var expressionFunctionString = "(function(__eval, __currentExpression, " + parameterNames.join(", ") + ") { " + expressionFunctionBody + " })";
+        } else {
+            // Use a closure in this case too to keep the same behavior of 'var' being captured by the closure instead
+            // of leaking out into the calling scope.
+            var expressionFunctionString = "(function(__eval, __currentExpression) { " + expressionFunctionBody + " })";
+        }
+
+        // Bind 'this' to the function expression using another closure instead of Function.prototype.bind. This ensures things will work if the page replaces bind.
+        var boundExpressionFunctionString = "(function(__function, __thisObject) { return function() { return __function.apply(__thisObject, arguments) }; })(" + expressionFunctionString + ", this)";
+        var expressionFunction = evalFunction.call(object, boundExpressionFunctionString);
+        var result = expressionFunction.apply(null, parameters);
+
+        if (objectGroup === "console")
+            this._lastResult = result;
+
+        return result;
     },