Refactoring XSLT

Source/core/xml/DocumentXSLT.cpp

+#include "config.h"

[haraken, 2014/11/17 14:18:31]

Add a copyright.

[tasak, 2014/11/19 08:23:17]

Done.

+#include "core/xml/DocumentXSLT.h"
+
+#include "bindings/core/v8/DOMWrapperWorld.h"
+#include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/V8AbstractEventListener.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "core/dom/Document.h"
+#include "core/dom/Node.h"
+#include "core/dom/ProcessingInstruction.h"
+#include "core/events/Event.h"
+#include "core/events/EventListener.h"
+#include "core/frame/UseCounter.h"
+#include "core/inspector/InspectorInstrumentation.h"
+#include "core/xml/XSLStyleSheet.h"
+#include "core/xml/XSLTProcessor.h"
+
+namespace blink {
+
+namespace {

[haraken, 2014/11/17 14:18:31]

What is this namespace for?

[tasak, 2014/11/19 08:23:17]

Done.

+
+class DOMContentLoadedListener : public V8AbstractEventListener {
+public:
+    virtual bool operator==(const EventListener&)
+    {
+        return true;
+    }
+
+    virtual void handleEvent(ExecutionContext* context, Event* event)
+    {
+        ASSERT(event->type() == "DOMContentLoaded");
+        ScriptState::Scope scope(scriptState());
+
+        Document& document = *toDocument(context);
+        // Processing instruction (XML documents only).
+        // We don't support linking to embedded CSS stylesheets, see <https://bugs.webkit.org/show_bug.cgi?id=49281> for discussion.
+        // Don't apply XSL transforms to already transformed documents -- <rdar://problem/4132806>

[haraken, 2014/11/17 14:18:31]

Remove the rdar part.

[tasak, 2014/11/19 08:23:17]

Done.

+        if (DocumentXSLT::hasTransformSourceDocument(document))
+            return;
+
+        ProcessingInstruction* pi = DocumentXSLT::findXSLStyleSheet(document);
+        if (!pi || pi != m_processingInstruction.get() || pi->isLoading())
+            return;
+        DocumentXSLT::applyXSLTransform(document, pi);
+    }
+
+    static PassRefPtr<DOMContentLoadedListener> create(ScriptState* scriptState, ProcessingInstruction* pi)
+    {
+        return adoptRef(new DOMContentLoadedListener(scriptState, pi));
+    }
+
+private:
+    DOMContentLoadedListener(ScriptState* scriptState, ProcessingInstruction* pi)
+        : V8AbstractEventListener(false, scriptState)
+        , m_processingInstruction(pi)
+    {
+    }
+
+    virtual v8::Local<v8::Value> callListenerFunction(v8::Handle<v8::Value> jsevent, Event*)
+    {
+        ASSERT_NOT_REACHED();
+        return v8::Local<v8::Value>();
+    }
+
+    RefPtr<ProcessingInstruction> m_processingInstruction;

[haraken, 2014/11/17 14:18:31]

This should be RefPtrWillBePersistent. Let's confirm that this CL builds with
enable_oilpan=1.

[tasak, 2014/11/19 08:23:17]

Done.

+};
+
+}
+
+DocumentXSLT::DocumentXSLT()
+    : m_transformSourceDocument(nullptr)
+{
+}
+
+PassRefPtr<EventListener> DocumentXSLT::addDOMContentLoadedListenerForXSLT(Document& document, ProcessingInstruction* pi)
+{
+    if (!RuntimeEnabledFeatures::xsltEnabled())
+        return nullptr;
+
+    if (!document.frame())
+        return nullptr;
+
+    v8::HandleScope handleScope(v8::Isolate::GetCurrent());
+    v8::Local<v8::Context> context = toV8Context(document.frame(), DOMWrapperWorld::mainWorld());

[haraken, 2014/11/17 14:18:31]

Is it guaranteed that this is for the main world?

[tasak, 2014/11/19 08:23:17]

According to offline discussion, for the main world.

+    ScriptState* scriptState = ScriptState::from(context);

[haraken, 2014/11/17 14:18:31]

You can use ScriptState::forMainWorld(document.frame()). Then you won't need to
create a HandleScope.

[tasak, 2014/11/19 08:23:17]

Done.

+
+    RefPtr<EventListener> listener = DOMContentLoadedListener::create(scriptState, pi);
+    document.addEventListener(EventTypeNames::DOMContentLoaded, listener, false);
+    return listener;
+}
+
+void DocumentXSLT::applyXSLTransform(Document& document, ProcessingInstruction* pi)
+{
+    ASSERT(!pi->isLoading());
+    UseCounter::count(document, UseCounter::XSLProcessingInstruction);
+    RefPtrWillBeRawPtr<XSLTProcessor> processor = XSLTProcessor::create(document);
+    processor->setXSLStyleSheet(toXSLStyleSheet(pi->sheet()));
+    String resultMIMEType;
+    String newSource;
+    String resultEncoding;
+    document.setParsingState(Document::Parsing);
+    if (!processor->transformToString(&document, resultMIMEType, newSource, resultEncoding)) {
+        document.setParsingState(Document::FinishedParsing);
+        return;
+    }
+    // FIXME: If the transform failed we should probably report an error (like Mozilla does).
+    LocalFrame* ownerFrame = document.frame();
+    processor->createDocumentFromSource(newSource, resultEncoding, resultMIMEType, &document, ownerFrame);
+    InspectorInstrumentation::frameDocumentUpdated(ownerFrame);
+    document.setParsingState(Document::FinishedParsing);
+}
+
+ProcessingInstruction* DocumentXSLT::findXSLStyleSheet(Document& document)
+{
+    for (Node* node = document.firstChild(); node; node = node->nextSibling()) {
+        if (node->nodeType() != Node::PROCESSING_INSTRUCTION_NODE)
+            continue;
+
+        ProcessingInstruction* pi = toProcessingInstruction(node);
+        if (pi->isXSL())
+            return pi;
+    }
+    return 0;
+}
+
+void DocumentXSLT::sheetLoaded(Document& document, ProcessingInstruction* pi)
+{
+    if (!RuntimeEnabledFeatures::xsltEnabled())
+        return;
+
+    if (document.parsing() || pi->isLoading())
+        return;
+
+    if (DocumentXSLT::hasTransformSourceDocument(document))
+        return;
+
+    ProcessingInstruction* firstPi = findXSLStyleSheet(document);
+    ASSERT(firstPi);
+    if (firstPi != pi)
+        return;
+    applyXSLTransform(document, pi);
+}
+
+const char* DocumentXSLT::supplementName()
+{
+    return "DocumentXSLT";
+}
+
+bool DocumentXSLT::hasTransformSourceDocument(Document& document)
+{
+    return static_cast<DocumentXSLT*>(DocumentSupplement::from(document, supplementName()));
+}
+
+
+DocumentXSLT& DocumentXSLT::from(DocumentSupplementable& document)
+{
+    DocumentXSLT* supplement = static_cast<DocumentXSLT*>(DocumentSupplement::from(document, supplementName()));
+    if (!supplement) {
+        supplement = new DocumentXSLT();
+        DocumentSupplement::provideTo(document, supplementName(), adoptPtrWillBeNoop(supplement));
+    }
+    return *supplement;
+}
+
+void DocumentXSLT::trace(Visitor* visitor)
+{
+    visitor->trace(m_transformSourceDocument);
+    DocumentSupplement::trace(visitor);
+}
+
+} // namespace blink