[Fetch API] Reflect spec changes of bodyUsed property

third_party/WebKit/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"
@@ skipping 16 matching lines @@
     USING_GARBAGE_COLLECTED_MIXIN(BodyStreamBuffer);
 public:
     // |handle| cannot be null and cannot be locked.
     explicit BodyStreamBuffer(PassOwnPtr<FetchDataConsumerHandle> /* handle */);
 
     ReadableByteStream* stream() { return m_stream; }
 
     // Callable only when not locked.
     PassRefPtr<BlobDataHandle> drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::BlobSizePolicy);
     PassRefPtr<EncodedFormData> drainAsFormData();
+    void startLoading(ExecutionContext*, FetchDataLoader*, FetchDataLoader::Client* /* client */);
 
     // Callable only when not locked. Returns a non-null handle.
-    // Note: There is a case that calling |lock| doesn't make the buffer
-    // 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*);
+    // There is no means to "return" the handle to the body buffer: Calling
+    // this function locks, disturbs and closes the stream and no one will
+    // not be able to get any information from the stream and this buffer after
+    // that.
+    PassOwnPtr<FetchDataConsumerHandle> releaseHandle(ExecutionContext*);
 
-    // This function will lock |this| object. |client| cannot be null.
-    void startLoading(ExecutionContext*, FetchDataLoader*, FetchDataLoader::Client* /* client */);
-
-    bool isLocked() const { return m_stream->isLocked(); }
-    bool hasPendingActivity() const { return isLocked() || m_lockLevel > 0; }
+    bool hasPendingActivity() const;
 
     // UnderlyingSource
     void pullSource() override;
     ScriptPromise cancelSource(ScriptState*, ScriptValue reason) override;
 
     // WebDataConsumerHandle::Client
     void didGetReadable() override;
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_stream);
-        visitor->trace(m_streamReader);
-        visitor->trace(m_loaders);
+        visitor->trace(m_loader);
         UnderlyingSource::trace(visitor);
     }
 
 private:
-    class LoaderHolder;
-    enum EndLoadingMode {
-        EndLoadingDone,
-        EndLoadingErrored,
-    };
+    class LoaderClient;
     void close();
     void error();
     void processData();
-    void unlock();
-    void endLoading(FetchDataLoader::Client*, EndLoadingMode);
+    void endLoading();
+    void stopLoading();
 
     OwnPtr<FetchDataConsumerHandle> m_handle;
     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;
+    // We need this member to keep it alive while loading.
+    Member<FetchDataLoader> m_loader;
     bool m_streamNeedsMore;
 };
 
 } // namespace blink
 
 #endif // BodyStreamBuffer_h