Add WARN_UNUSED_RESULT to BytesConsumer read methods.

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/Compiler.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.
 //
@@ skipping 53 matching lines @@
 
     // 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);
+    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) = 0;
+    virtual Result beginRead(const char** buffer, size_t* available) WARN_UNUSED_RESULT = 0;
 
     // Ends a two-phase read.
-    virtual Result endRead(size_t readSize) = 0;
+    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
     // 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.
@@ skipping 62 matching lines @@
             return PublicState::Errored;
         }
         NOTREACHED();
         return PublicState::ReadableOrWaiting;
     }
 };
 
 } // namespace blink
 
 #endif // BytesConsumer_h