+2009-03-17 Dimitri Glazkov <dglazkov@chromium.org>
+
+ Reviewed by Timothy Hatcher.
+
+ https://bugs.webkit.org/show_bug.cgi?id=24623
+ Refactor ConsoleMessage to use ScriptFuncitonCall and eliminate JSC
+ dependencies.
+
+ * bindings/js/ScriptFunctionCall.cpp:
+ (WebCore::ScriptFunctionCall::appendArgument): Added uint and ScriptString-taking methods.
+ * bindings/js/ScriptFunctionCall.h:
+ * bindings/js/ScriptObjectQuarantine.cpp:
+ (WebCore::quarantineValue): Added generic ScriptValue quarantine helper.
+ * bindings/js/ScriptObjectQuarantine.h:
+ * bindings/js/ScriptValue.cpp:
+ (WebCore::ScriptValue::isEqual): Added.
+ * bindings/js/ScriptValue.h:
+ * inspector/ConsoleMessage.cpp:
+ (WebCore::ConsoleMessage::ConsoleMessage):
+ (WebCore::ConsoleMessage::addToConsole): Added.
+ (WebCore::ConsoleMessage::isEqual): Changed to use ScriptValue::isEqual.
+ * inspector/ConsoleMessage.h:
+ (WebCore::ConsoleMessage::incrementCount): Added.
+ * inspector/InspectorController.cpp:
+ (WebCore::InspectorController::addConsoleMessage): Changed to use ConsoleMessage::addToConsole.
+ (WebCore::InspectorController::populateScriptObjects): Ditto.
+ * inspector/InspectorController.h:
+
2009-03-17 Kevin Ollivier <kevino@theolliviers.com>
Reviewed by Mark Rowe.
#include "ScriptFunctionCall.h"
#include "JSDOMBinding.h"
+#include "ScriptString.h"
#include "ScriptValue.h"
#include <runtime/JSLock.h>
m_arguments.append(argument.jsObject());
}
+void ScriptFunctionCall::appendArgument(const ScriptString& argument)
+{
+ m_arguments.append(jsString(m_exec, argument));
+}
+
void ScriptFunctionCall::appendArgument(const ScriptValue& argument)
{
m_arguments.append(argument.jsValue());
m_arguments.append(jsString(m_exec, argument));
}
+void ScriptFunctionCall::appendArgument(unsigned int argument)
+{
+ JSLock lock(false);
+ m_arguments.append(jsNumber(m_exec, argument));
+}
+
void ScriptFunctionCall::appendArgument(bool argument)
{
m_arguments.append(jsBoolean(argument));
namespace WebCore {
class ScriptValue;
+ class ScriptString;
class ScriptFunctionCall {
public:
virtual ~ScriptFunctionCall() {};
void appendArgument(const ScriptObject&);
+ void appendArgument(const ScriptString&);
void appendArgument(const ScriptValue&);
void appendArgument(const String&);
+ void appendArgument(unsigned int);
void appendArgument(bool);
ScriptValue call(bool& hadException);
ScriptObject construct(bool& hadException);
#include "JSDOMBinding.h"
#include "JSInspectedObjectWrapper.h"
#include "ScriptObject.h"
+#include "ScriptValue.h"
#include <runtime/JSLock.h>
namespace WebCore {
+ScriptValue quarantineValue(ScriptState* scriptState, const ScriptValue& value)
+{
+ JSLock lock(false);
+ return ScriptValue(JSInspectedObjectWrapper::wrap(scriptState, value.jsValue()));
+}
+
bool getQuarantinedScriptObject(Database* database, ScriptObject& quarantinedObject)
{
ASSERT(database);
#ifndef ScriptObjectQuarantine_h
#define ScriptObjectQuarantine_h
+#include "ScriptState.h"
+
namespace WebCore {
class Database;
class Frame;
class ScriptObject;
+ class ScriptValue;
class Storage;
+ ScriptValue quarantineValue(ScriptState*, const ScriptValue&);
+
bool getQuarantinedScriptObject(Database* database, ScriptObject& quarantinedObject);
bool getQuarantinedScriptObject(Frame* frame, Storage* storage, ScriptObject& quarantinedObject);
#include "config.h"
#include "ScriptValue.h"
+#include <JavaScriptCore/APICast.h>
+#include <JavaScriptCore/JSValueRef.h>
+
#include <runtime/JSLock.h>
#include <runtime/Protect.h>
#include <runtime/UString.h>
return true;
}
+bool ScriptValue::isEqual(ScriptState* scriptState, const ScriptValue& anotherValue) const
+{
+ if (hasNoValue())
+ return anotherValue.hasNoValue();
+
+ return JSValueIsEqual(toRef(scriptState), toRef(jsValue()), toRef(anotherValue.jsValue()), 0);
+}
+
bool ScriptValue::isNull() const
{
if (!m_value)
JSC::JSValuePtr jsValue() const { return m_value.get(); }
bool getString(String& result) const;
String toString(ScriptState* scriptState) const { return m_value.get().toString(scriptState); }
+ bool isEqual(ScriptState*, const ScriptValue&) const;
bool isNull() const;
bool isUndefined() const;
bool hasNoValue() const { return m_value == JSC::noValue(); }
#include "ConsoleMessage.h"
#include "JSInspectedObjectWrapper.h"
-#include "ScriptString.h"
#include "ScriptCallStack.h"
#include "ScriptCallFrame.h"
-
-#include <JavaScriptCore/APICast.h>
-#include <JavaScriptCore/JSValueRef.h>
-#include <runtime/JSLock.h>
-
-using namespace JSC;
+#include "ScriptFunctionCall.h"
+#include "ScriptObjectQuarantine.h"
+#include "ScriptString.h"
namespace WebCore {
ConsoleMessage::ConsoleMessage(MessageSource s, MessageLevel l, const String& m, unsigned li, const String& u, unsigned g)
- : source(s)
- , level(l)
- , message(m)
- , line(li)
- , url(u)
- , groupLevel(g)
- , repeatCount(1)
+ : m_source(s)
+ , m_level(l)
+ , m_message(m)
+ , m_line(li)
+ , m_url(u)
+ , m_groupLevel(g)
+ , m_repeatCount(1)
{
}
ConsoleMessage::ConsoleMessage(MessageSource s, MessageLevel l, ScriptCallStack* callStack, unsigned g, bool storeTrace)
- : source(s)
- , level(l)
- , wrappedArguments(callStack->at(0).argumentCount())
- , frames(storeTrace ? callStack->size() : 0)
- , groupLevel(g)
- , repeatCount(1)
+ : m_source(s)
+ , m_level(l)
+ , m_wrappedArguments(callStack->at(0).argumentCount())
+ , m_frames(storeTrace ? callStack->size() : 0)
+ , m_groupLevel(g)
+ , m_repeatCount(1)
{
const ScriptCallFrame& lastCaller = callStack->at(0);
- line = lastCaller.lineNumber();
- url = lastCaller.sourceURL().string();
+ m_line = lastCaller.lineNumber();
+ m_url = lastCaller.sourceURL().string();
// FIXME: For now, just store function names as strings.
// As ScriptCallStack start storing line number and source URL for all
// frames, refactor to use that, as well.
if (storeTrace) {
- unsigned stackSize = callStack->size();
- for (unsigned i = 0; i < stackSize; ++i)
- frames[i] = callStack->at(i).functionName();
+ for (unsigned i = 0; i < callStack->size(); ++i)
+ m_frames[i] = callStack->at(i).functionName();
}
- JSLock lock(false);
-
for (unsigned i = 0; i < lastCaller.argumentCount(); ++i)
- wrappedArguments[i] = JSInspectedObjectWrapper::wrap(callStack->state(), lastCaller.argumentAt(i).jsValue());
+ m_wrappedArguments[i] = quarantineValue(callStack->state(), lastCaller.argumentAt(i));
}
-bool ConsoleMessage::isEqual(ExecState* exec, ConsoleMessage* msg) const
+void ConsoleMessage::addToConsole(ScriptState* scriptState, const ScriptObject& webInspector)
{
- if (msg->wrappedArguments.size() != this->wrappedArguments.size() ||
- (!exec && msg->wrappedArguments.size()))
+ ScriptFunctionCall messageConstructor(scriptState, webInspector, "ConsoleMessage");
+ messageConstructor.appendArgument(static_cast<unsigned int>(m_source));
+ messageConstructor.appendArgument(static_cast<unsigned int>(m_level));
+ messageConstructor.appendArgument(m_line);
+ messageConstructor.appendArgument(m_url);
+ messageConstructor.appendArgument(m_groupLevel);
+ messageConstructor.appendArgument(m_repeatCount);
+
+ if (!m_frames.isEmpty()) {
+ for (unsigned i = 0; i < m_frames.size(); ++i)
+ messageConstructor.appendArgument(m_frames[i]);
+ } else if (!m_wrappedArguments.isEmpty()) {
+ for (unsigned i = 0; i < m_wrappedArguments.size(); ++i)
+ messageConstructor.appendArgument(m_wrappedArguments[i]);
+ } else
+ messageConstructor.appendArgument(m_message);
+
+ bool hadException = false;
+ ScriptObject message = messageConstructor.construct(hadException);
+ if (hadException)
+ return;
+
+ ScriptFunctionCall addMessageToConsole(scriptState, webInspector, "addMessageToConsole");
+ addMessageToConsole.appendArgument(message);
+ addMessageToConsole.call(hadException);
+}
+
+bool ConsoleMessage::isEqual(ScriptState* state, ConsoleMessage* msg) const
+{
+ if (msg->m_wrappedArguments.size() != m_wrappedArguments.size() ||
+ (!state && msg->m_wrappedArguments.size()))
return false;
- for (size_t i = 0; i < msg->wrappedArguments.size(); ++i) {
- ASSERT_ARG(exec, exec);
- if (!JSValueIsEqual(toRef(exec), toRef(msg->wrappedArguments[i].get()), toRef(this->wrappedArguments[i].get()), 0))
+ ASSERT_ARG(state, state);
+
+ for (size_t i = 0; i < msg->m_wrappedArguments.size(); ++i)
+ if (!m_wrappedArguments[i].isEqual(state, msg->m_wrappedArguments[i]))
return false;
- }
- size_t frameCount = msg->frames.size();
- if (frameCount != this->frames.size())
+ size_t frameCount = msg->m_frames.size();
+ if (frameCount != m_frames.size())
return false;
- for (size_t i = 0; i < frameCount; ++i) {
- const ScriptString& myFrameFunctionName = this->frames[i];
- if (myFrameFunctionName != msg->frames[i])
+ for (size_t i = 0; i < frameCount; ++i)
+ if (m_frames[i] != msg->m_frames[i])
return false;
- }
- return msg->source == this->source
- && msg->level == this->level
- && msg->message == this->message
- && msg->line == this->line
- && msg->url == this->url
- && msg->groupLevel == this->groupLevel;
+ return msg->m_source == m_source
+ && msg->m_level == m_level
+ && msg->m_message == m_message
+ && msg->m_line == m_line
+ && msg->m_url == m_url
+ && msg->m_groupLevel == m_groupLevel;
}
} // namespace WebCore
#define ConsoleMessage_h
#include "Console.h"
+#include "ScriptObject.h"
+#include "ScriptState.h"
#include <runtime/Protect.h>
#include <wtf/Vector.h>
-namespace JSC {
- class ExecState;
-}
-
namespace WebCore {
class ScriptCallStack;
ConsoleMessage(MessageSource, MessageLevel, const String& m, unsigned li, const String& u, unsigned g);
ConsoleMessage(MessageSource, MessageLevel, ScriptCallStack*, unsigned g, bool storeTrace = false);
- bool isEqual(JSC::ExecState* exec, ConsoleMessage* msg) const;
+ void addToConsole(ScriptState*, const ScriptObject& webInspector);
+ void incrementCount() { ++m_repeatCount; };
+ bool isEqual(ScriptState*, ConsoleMessage* msg) const;
- MessageSource source;
- MessageLevel level;
- String message;
- Vector<JSC::ProtectedJSValuePtr> wrappedArguments;
- Vector<ScriptString> frames;
- unsigned line;
- String url;
- unsigned groupLevel;
- unsigned repeatCount;
+ private:
+ MessageSource m_source;
+ MessageLevel m_level;
+ String m_message;
+ Vector<ScriptValue> m_wrappedArguments;
+ Vector<ScriptString> m_frames;
+ unsigned m_line;
+ String m_url;
+ unsigned m_groupLevel;
+ unsigned m_repeatCount;
};
} // namespace WebCore
ASSERT_ARG(consoleMessage, consoleMessage);
if (m_previousMessage && m_previousMessage->isEqual(exec, consoleMessage)) {
- ++m_previousMessage->repeatCount;
+ m_previousMessage->incrementCount();
delete consoleMessage;
} else {
m_previousMessage = consoleMessage;
}
if (windowVisible())
- addScriptConsoleMessage(m_previousMessage);
+ m_previousMessage->addToConsole(toJS(m_scriptContext), ScriptObject(toJS(m_scriptObject)));
}
void InspectorController::clearConsoleMessages()
unsigned messageCount = m_consoleMessages.size();
for (unsigned i = 0; i < messageCount; ++i)
- addScriptConsoleMessage(m_consoleMessages[i]);
+ m_consoleMessages[i]->addToConsole(toJS(m_scriptContext), ScriptObject(toJS(m_scriptObject)));
#if ENABLE(DATABASE)
DatabaseResourcesSet::iterator databasesEnd = m_databaseResources.end();
callSimpleFunction(m_scriptContext, m_scriptObject, "populateInterface");
}
-void InspectorController::addScriptConsoleMessage(const ConsoleMessage* message)
-{
- ASSERT_ARG(message, message);
-
- JSValueRef exception = 0;
-
- JSValueRef messageConstructorProperty = JSObjectGetProperty(m_scriptContext, m_scriptObject, jsStringRef("ConsoleMessage").get(), &exception);
- if (HANDLE_EXCEPTION(m_scriptContext, exception))
- return;
-
- JSObjectRef messageConstructor = JSValueToObject(m_scriptContext, messageConstructorProperty, &exception);
- if (HANDLE_EXCEPTION(m_scriptContext, exception))
- return;
-
- JSValueRef sourceValue = JSValueMakeNumber(m_scriptContext, message->source);
- JSValueRef levelValue = JSValueMakeNumber(m_scriptContext, message->level);
- JSValueRef lineValue = JSValueMakeNumber(m_scriptContext, message->line);
- JSValueRef urlValue = JSValueMakeString(m_scriptContext, jsStringRef(message->url).get());
- JSValueRef groupLevelValue = JSValueMakeNumber(m_scriptContext, message->groupLevel);
- JSValueRef repeatCountValue = JSValueMakeNumber(m_scriptContext, message->repeatCount);
-
- static const unsigned maximumMessageArguments = 256;
- JSValueRef arguments[maximumMessageArguments];
- unsigned argumentCount = 0;
- arguments[argumentCount++] = sourceValue;
- arguments[argumentCount++] = levelValue;
- arguments[argumentCount++] = lineValue;
- arguments[argumentCount++] = urlValue;
- arguments[argumentCount++] = groupLevelValue;
- arguments[argumentCount++] = repeatCountValue;
-
- if (!message->frames.isEmpty()) {
- unsigned remainingSpaceInArguments = maximumMessageArguments - argumentCount;
- unsigned argumentsToAdd = min(remainingSpaceInArguments, static_cast<unsigned>(message->frames.size()));
- for (unsigned i = 0; i < argumentsToAdd; ++i)
- arguments[argumentCount++] = JSValueMakeString(m_scriptContext, jsStringRef(message->frames[i]).get());
- } else if (!message->wrappedArguments.isEmpty()) {
- unsigned remainingSpaceInArguments = maximumMessageArguments - argumentCount;
- unsigned argumentsToAdd = min(remainingSpaceInArguments, static_cast<unsigned>(message->wrappedArguments.size()));
- for (unsigned i = 0; i < argumentsToAdd; ++i)
- arguments[argumentCount++] = toRef(message->wrappedArguments[i]);
- } else {
- JSValueRef messageValue = JSValueMakeString(m_scriptContext, jsStringRef(message->message).get());
- arguments[argumentCount++] = messageValue;
- }
-
- JSObjectRef messageObject = JSObjectCallAsConstructor(m_scriptContext, messageConstructor, argumentCount, arguments, &exception);
- if (HANDLE_EXCEPTION(m_scriptContext, exception))
- return;
-
- callFunction(m_scriptContext, m_scriptObject, "addMessageToConsole", 1, &messageObject, exception);
-}
-
void InspectorController::addScriptProfile(Profile* profile)
{
JSLock lock(false);
void focusNode();
void addConsoleMessage(JSC::ExecState*, ConsoleMessage*);
- void addScriptConsoleMessage(const ConsoleMessage*);
void addResource(InspectorResource*);
void removeResource(InspectorResource*);
git://git.webkit.org / WebKit-https.git / commitdiff