Implment BytesConsumer::tee

third_party/WebKit/Source/modules/fetch/BytesConsumer.h

 // Copyright 2016 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 BytesConsumer_h
 #define BytesConsumer_h
 
 #include "modules/ModulesExport.h"
 #include "platform/blob/BlobData.h"
 #include "platform/heap/Handle.h"
 #include "platform/network/EncodedFormData.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
+class ExecutionContext;
+
 // BytesConsumer represents the "consumer" side of a data pipe. A user
 // can read data from it.
 //
 // A BytesConsumer is bound to the thread on which it is created.
 // BytesConsumer has four states: waiting, readable, closed and errored. Once
 // the state becomes closed or errored, it will never change. |readable| means
 // that the BytesConsumer is ready to read non-empty bytes synchronously.
 class MODULES_EXPORT BytesConsumer : public GarbageCollectedFinalized<BytesConsumer> {
 public:
     enum class Result {
@@ skipping 57 matching lines @@
 
     // Begins a two-phase read. On success, the function stores a buffer
     // that contains the read data of length |*available| into |*buffer|.
     // Returns Ok when readable.
     // Returns ShouldWait when it's waiting.
     // Returns Done when it's closed.
     // Returns Error when errored.
     // When not readable, the caller don't have to (and must not) call
     // endRead, because the read session implicitly ends in that case.
     //
+    // |*buffer| will become invalid when this object becomes unreachable,
+    // even if endRead is not called.
+    //
     // |*buffer| will be set to null and |*available| will be set to 0 if not
     // readable.
     virtual Result beginRead(const char** buffer, size_t* available) = 0;
 
     // Ends a two-phase read.
     virtual Result endRead(size_t readSize) = 0;
 
     // Drains the data as a BlobDataHandle.
     // When this function returns a non-null value, the returned blob handle
     // contains bytes that would be read through read, beginRead and
     // endRead functions without calling this function. In such a case, this
     // object becomes closed.
     // When this function returns null value, this function does nothing.
     // When |policy| is DisallowBlobWithInvalidSize, this function doesn't
     // return a non-null blob handle with unspecified size.
     // The type of the returned blob handle may not be meaningful.
     virtual PassRefPtr<BlobDataHandle> drainAsBlobDataHandle(BlobSizePolicy = BlobSizePolicy::DisallowBlobWithInvalidSize) { return nullptr; }
 
     // Drains the data as an EncodedFormData.
     // When this function returns a non-null value, the returned form data
     // contains bytes that would be read through read, beginRead and
     // endRead functions without calling this function. In such a case, this
     // object becomes closed.
     // When this function returns null value, this function does nothing.
     // This function returns a non-null form data when the handle is made
     // from an EncodedFormData-convertible value.
     virtual PassRefPtr<EncodedFormData> drainAsFormData() { return nullptr; }
 
-    // Sets a client.
+    // Sets a client. This can be called only when no client is set. When
+    // this object is already closed or errored, this function does nothing.
     virtual void setClient(Client*) = 0;
-    // Clears the set client. This can be called only when a client is set.
+    // Clears the set client.
+    // A client will be implicitly cleared when this object gets closed or
+    // errored (after the state change itself is notified).
     virtual void clearClient() = 0;
 
     // Cancels this ByteConsumer. This function does nothing when |this| is
     // already closed or errored. Otherwise, this object becomes closed.
+    // This function cannot be called in a two-phase read.
     virtual void cancel() = 0;
 
     // Returns the current state.
     virtual PublicState getPublicState() const = 0;
 
     // Returns the associated error of this object. This function can be called
     // only when errored.
     virtual Error getError() const = 0;
 
     // Each implementation should return a string that represents the
     // implementation for debug purpose.
     virtual String debugName() const = 0;
 
+    // Creates two BytesConsumer both of which represent the data sequence that
+    // would be read from |src| and store them to |*dest1| and |*dest2|.
+    // |src| must not have a client when called.
+    static void tee(ExecutionContext*, BytesConsumer* src, BytesConsumer** dest1, BytesConsumer** dest2);
+
     DEFINE_INLINE_VIRTUAL_TRACE() {}
 
 protected:
     // This InternalState directly corresponds to the states in the class
     // comments. This enum is defined here for subclasses.
     enum class InternalState {
         Readable,
         Waiting,
         Closed,
         Errored,
@@ skipping 11 matching lines @@
             return PublicState::Errored;
         }
         NOTREACHED();
         return PublicState::ReadableOrWaiting;
     }
 };
 
 } // namespace blink
 
 #endif // BytesConsumer_h