Remove BytesConsumer::read

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"
@@ skipping 56 matching lines @@
         //
         // This function is not called when the state change is trigerred by
         // public methods called by a user. For example, when a user reads
         // data by |read| and the state changes from waiting to readable, this
         // function will not be called.
         virtual void onStateChange() = 0;
     };
 
     virtual ~BytesConsumer() {}
 
-    // Reads data into |buffer| up to |size| bytes. The actual read size will
-    // be stored in |*readSize|. This function cannot be called when a two-phase
-    // read is in progress.
-    // Returns Ok when readable.
-    // Returns ShouldWait when it's waiting.
-    // Returns Done when closed.
-    // Returns Error when errored.
-    // |buffer| can be null if |size| is 0.
-    // |*readSize| will be set to 0 if not readable.
-    virtual Result read(char* buffer, size_t /* size */, size_t* readSize) WARN_UNUSED_RESULT;
-
     // 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) WARN_UNUSED_RESULT = 0;
 
     // Ends a two-phase read.
     virtual Result endRead(size_t readSize) WARN_UNUSED_RESULT = 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
+    // contains bytes that would be read through 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
+    // contains bytes that would be read through 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. 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;
@@ skipping 47 matching lines @@
             return PublicState::Errored;
         }
         NOTREACHED();
         return PublicState::ReadableOrWaiting;
     }
 };
 
 } // namespace blink
 
 #endif // BytesConsumer_h