[Fetch API] Remove DrainingBuffer.

Source/modules/fetch/BodyStreamBuffer.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BodyStreamBuffer_h
 #define BodyStreamBuffer_h
 
 #include "core/dom/DOMException.h"
+#include "core/streams/ReadableByteStream.h"
+#include "core/streams/ReadableByteStreamReader.h"
+#include "core/streams/UnderlyingSource.h"
 #include "modules/ModulesExport.h"
-#include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchDataConsumerHandle.h"
 #include "modules/fetch/FetchDataLoader.h"
-#include "platform/blob/BlobData.h"
-#include "platform/heap/Heap.h"
+#include "platform/heap/Handle.h"
 #include "public/platform/WebDataConsumerHandle.h"
-#include "wtf/Deque.h"
-#include "wtf/RefPtr.h"
-#include "wtf/text/WTFString.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
 
 namespace blink {
 
-class DrainingBodyStreamBuffer;
+class ExecutionContext;
 
-class MODULES_EXPORT BodyStreamBuffer final : public GarbageCollectedFinalized<BodyStreamBuffer> {
+// A BodyStreamBuffer constructed with a null handle is said to have null body.
+// One can observe if a buffer has null body by calling |hasBody| function.
+// |stream| function returns a non-null stream even when the buffer has null
+// body.
+class MODULES_EXPORT BodyStreamBuffer final : public GarbageCollectedFinalized<BodyStreamBuffer>, public UnderlyingSource, public WebDataConsumerHandle::Client {
+    WTF_MAKE_NONCOPYABLE(BodyStreamBuffer);
+    USING_GARBAGE_COLLECTED_MIXIN(BodyStreamBuffer);
 public:
-    static BodyStreamBuffer* create(PassOwnPtr<FetchDataConsumerHandle> handle) { return new BodyStreamBuffer(handle); }
-    static BodyStreamBuffer* createEmpty();
+    BodyStreamBuffer() : BodyStreamBuffer(nullptr) {}
+    // |handle| can be null, but cannot be locked.
+    explicit BodyStreamBuffer(PassOwnPtr<FetchDataConsumerHandle> /* handle */);
 
-    FetchDataConsumerHandle* handle() const;
-    PassOwnPtr<FetchDataConsumerHandle> releaseHandle();
+    ReadableByteStream* stream() { return m_stream; }
 
-    class MODULES_EXPORT DrainingStreamNotificationClient : public GarbageCollectedMixin {
-    public:
-        virtual ~DrainingStreamNotificationClient() { }
-        // Called after FetchDataLoader::Client methods.
-        virtual void didFetchDataLoadFinishedFromDrainingStream() = 0;
-    };
+    // Callable only when not locked. Returns a non-null handle even when
+    // having null body.
+    // Note: There is a case that calling |lock| doesn't make the buffer

[hiroshige, 2015/07/21 12:14:01]

The comments L40--L42, L44--L45 are complicated, and this is because the
inconsistency between the names lock()/unlock() and the name
isLocked()/ReadableByteStream::isLocked().
Probably changing the names lock()/unlock() to better names will resolve the
problem; use the word "locked" for ReadableByteStream, and another word for
BodyStreamBuffer. (currently no idea for the new name though...)

[yhirano, 2015/07/22 09:42:45]

As we discussed, I moved |unlock| to the private section and added
drainAsBlobDataHandle.

+    // locked. |unlock| should be called even in such cases when a user finishes
+    // to use the returned handle, in order to maintain hasPendingActivity().
+    PassOwnPtr<FetchDataConsumerHandle> lock(ExecutionContext*);

[hiroshige, 2015/07/21 12:14:01]

In my understanding of this CL:
- lock()/unlock() should be carefully used (because human cannot book-keep
lock()-unlock() correspondence in general), and should be used inside
BodyStreamBuffer internally.
- But lock() is public due to two call sites to lock() outside BodyStreamBuffer,
which do not have corresponding unlock() (and we are not sure when to call
unlock()) and are to be removed (have such TODO comments). These call sites of
lock() corresponds to previous BodyStreamBuffer::releaseBuffer() calls (which
were also not so clean interface).
If this is correct, please add TODO comments to lock() (and possibly to
unlock()) that lock()/unlock() should be encapsulated in BodyStreamBuffer and
made private, and external users should not use lock()/unlock().

[yhirano, 2015/07/22 09:42:45]

ditto

+    // Callable even when not locked, but there should be one-to-one
+    // correspondence between |lock| and |unlock| calls. |handle| must not be
+    // locked. |handle| can be null only if this buffer has null body.
+    void unlock(PassOwnPtr<FetchDataConsumerHandle> /* handle */);

[hiroshige, 2015/07/21 12:14:01]

Please add a comment for what is |handle|.

[yhirano, 2015/07/22 09:42:45]

Removed.

+    // This function will lock |this| object. |unlock| will be called
+    // automatically when the loading finishes. |client| cannot be null.
+    void startLoading(ExecutionContext*, FetchDataLoader*, FetchDataLoader::Client* /* client */);
+
+    bool isLocked() const { return m_stream->isLocked(); }
+    bool hasBody() const { return m_hasBody; }
+    bool hasPendingActivity() const { return isLocked() || m_lockLevel > 0; }
+
+    // UnderlyingSource
+    void pullSource() override;
+    ScriptPromise cancelSource(ScriptState*, ScriptValue reason) override;
+
+    // WebDataConsumerHandle::Client
+    void didGetReadable() override;
+
+    // External users should not call this function.
+    void endLoading(FetchDataLoader::Client*, PassOwnPtr<FetchDataConsumerHandle>);
 
     DEFINE_INLINE_TRACE()
     {
-        visitor->trace(m_fetchDataLoader);
-        visitor->trace(m_drainingStreamNotificationClient);
+        visitor->trace(m_stream);
+        visitor->trace(m_streamReader);
+        visitor->trace(m_loaders);
+        UnderlyingSource::trace(visitor);
     }
 
-    void didFetchDataLoadFinished();
-
 private:
-    explicit BodyStreamBuffer(PassOwnPtr<FetchDataConsumerHandle> handle) : m_handle(handle) { }
-
-    void setDrainingStreamNotificationClient(DrainingStreamNotificationClient*);
-
-    void startLoading(FetchDataLoader*, FetchDataLoader::Client*);
-    // Call DrainingStreamNotificationClient.
-    void doDrainingStreamNotification();
-    // Clear DrainingStreamNotificationClient without calling.
-    void clearDrainingStreamNotification();
-
-    friend class DrainingBodyStreamBuffer;
+    void processData();
+    void close();
+    void error();
 
     OwnPtr<FetchDataConsumerHandle> m_handle;
-    Member<FetchDataLoader> m_fetchDataLoader;
-    Member<DrainingStreamNotificationClient> m_drainingStreamNotificationClient;
-};
-
-// DrainingBodyStreamBuffer wraps BodyStreamBuffer returned from
-// Body::createDrainingStream() and calls DrainingStreamNotificationClient
-// callbacks unless leakBuffer() is called:
-// - If startLoading() is called, the callback is called after loading finished.
-// - If drainAsBlobDataHandle() is called, the callback is called immediately.
-// - If leakBuffer() is called, the callback is no longer called.
-// Any calls to DrainingBodyStreamBuffer methods after a call to either of
-// methods above is no-op.
-// After calling one of the methods above, we don't have to keep
-// DrainingBodyStreamBuffer alive.
-// If DrainingBodyStreamBuffer is destructed before any of above is called,
-// the callback is called at destruction.
-class MODULES_EXPORT DrainingBodyStreamBuffer final {
-public:
-    static PassOwnPtr<DrainingBodyStreamBuffer> create(BodyStreamBuffer* buffer, BodyStreamBuffer::DrainingStreamNotificationClient* client)
-    {
-        return adoptPtr(new DrainingBodyStreamBuffer(buffer, client));
-    }
-    ~DrainingBodyStreamBuffer();
-    void startLoading(FetchDataLoader*, FetchDataLoader::Client*);
-    BodyStreamBuffer* leakBuffer();
-    PassRefPtr<BlobDataHandle> drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::BlobSizePolicy);
-
-private:
-    DrainingBodyStreamBuffer(BodyStreamBuffer*, BodyStreamBuffer::DrainingStreamNotificationClient*);
-
-    Persistent<BodyStreamBuffer> m_buffer;
+    OwnPtr<FetchDataConsumerHandle::Reader> m_reader;
+    Member<ReadableByteStream> m_stream;
+    Member<ReadableByteStreamReader> m_streamReader;
+    HeapHashSet<Member<FetchDataLoader::Client>> m_loaders;
+    // We need this variable because we cannot lock closed or erroed stream
+    // although we should return true for hasPendingActivity() when someone
+    // calls |startLoading| but the loding is not yet done.
+    unsigned m_lockLevel;
+    const bool m_hasBody;
+    bool m_streamNeedsMore;
 };
 
 } // namespace blink
 
 #endif // BodyStreamBuffer_h