Stream scripts to V8 as they load - Blink side.

Source/core/dom/PendingScript.h

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "core/fetch/ResourceOwner.h"
 #include "core/fetch/ScriptResource.h"
 #include "platform/heap/Handle.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/TextPosition.h"
 
 namespace blink {
 
 class ScriptResource;
+class V8ScriptStreamer;
 
 // A container for an external script which may be loaded and executed.
 //
 // A ResourcePtr alone does not prevent the underlying Resource
 // from purging its data buffer. This class holds a dummy client open for its
 // lifetime in order to guarantee that the data buffer will not be purged.
 class PendingScript FINAL : public ResourceOwner<ScriptResource> {
     ALLOW_ONLY_INLINE_ALLOCATION();
 public:
     PendingScript()
@@ skipping 21 matching lines @@
     ~PendingScript();
 
     PendingScript& operator=(const PendingScript& other)
     {
         if (this == &other)
             return *this;
 
         m_watchingForLoad = other.m_watchingForLoad;
         m_element = other.m_element;
         m_startingPosition = other.m_startingPosition;
-        this->ResourceOwner<ScriptResource, ResourceClient>::operator=(other);
-
+        m_streamer = other.m_streamer;
+        this->ResourceOwner<ScriptResource, ScriptResourceClient>::operator=(other);
         return *this;
     }
 
     TextPosition startingPosition() const { return m_startingPosition; }
     void setStartingPosition(const TextPosition& position) { m_startingPosition = position; }
 
     bool watchingForLoad() const { return m_watchingForLoad; }
     void setWatchingForLoad(bool b) { m_watchingForLoad = b; }
 
     Element* element() const { return m_element.get(); }
     void setElement(Element* element) { m_element = element; }
     PassRefPtrWillBeRawPtr<Element> releaseElementAndClear();
 
     void setScriptResource(ScriptResource*);
 
     virtual void notifyFinished(Resource*);
+    virtual void notifyAppendData(ScriptResource*);
 
     void trace(Visitor*);
 
+    void setStreamer(PassRefPtr<V8ScriptStreamer> streamer)
+    {
+        ASSERT(!m_streamer);
+        m_streamer = RefPtr<V8ScriptStreamer>(streamer);

[haraken, 2014/08/17 16:05:28]

RefPtr<V8ScriptStreamer> wouldn't be needed.

[marja, 2014/08/20 11:45:56]

Done.

+    }
+    V8ScriptStreamer* streamer() { return m_streamer.get(); }
+    PassRefPtr<V8ScriptStreamer> releaseStreamer() { return m_streamer.release(); }

[haraken, 2014/08/17 16:05:28]

Is it possible that releaseStreamer() is called before
streamer->notifyFinished() is called? If so, that seems problematic because no
one will call streamer->notifyFinished() after the PendingScript releases the
streamer. If no, can we add an ASSERT about it?

The point is that we want to make sure that notifyFinished is certainly called.
Otherwise, it will cause dead lock.

[marja, 2014/08/20 11:45:56]

I removed releaseStreamer, since the ownership dance was more complicated than
needed. So PendingScript continues to hold a reference.

However, when we actually release the streamer in setScriptResource,  it must be
that it's not streaming... so I added an assert there.

+
+    bool isStreaming() const;
+
 private:
     bool m_watchingForLoad;
     RefPtrWillBeMember<Element> m_element;
     TextPosition m_startingPosition; // Only used for inline script tags.
+
+    RefPtr<V8ScriptStreamer> m_streamer;
 };
 
 }
 
 #endif