Update from https://crrev.com/315085

net/base/file_stream_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "net/base/file_stream.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 528 matching lines @@
       waiting_for_result_ = true;
       base::RunLoop().Run();
       waiting_for_result_ = false;
     }
     have_result_ = false;  // auto-reset for next callback
     return result_;
   }
 
   const CompletionCallback& callback() const { return callback_; }
 
+  void ValidateWrittenData() {
+    TestCompletionCallback callback;
+    int rv = 0;
+    for (;;) {
+      scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
+      rv = stream_->Read(buf.get(), buf->size(), callback.callback());
+      if (rv == ERR_IO_PENDING) {
+        base::MessageLoop::ScopedNestableTaskAllower allow(
+            base::MessageLoop::current());
+        rv = callback.WaitForResult();
+      }
+      EXPECT_LE(0, rv);
+      if (rv <= 0)
+        break;
+      *total_bytes_read_ += rv;
+      data_read_->append(buf->data(), rv);
+    }
+  }
+
  private:
   void OnComplete(int result) {
     DCHECK_LT(0, result);
     *total_bytes_written_ += result;
 
     int rv;
 
     if (*total_bytes_written_ != kTestDataSize) {
       // Recurse to finish writing all data.
       int total_bytes_written = 0, total_bytes_read = 0;
@@ skipping 11 matching lines @@
     } else {  // We're done writing all data.  Start reading the data.
       TestInt64CompletionCallback callback64;
       EXPECT_EQ(ERR_IO_PENDING,
                 stream_->Seek(base::File::FROM_BEGIN, 0,
                               callback64.callback()));
       {
         base::MessageLoop::ScopedNestableTaskAllower allow(
             base::MessageLoop::current());
         EXPECT_LE(0, callback64.WaitForResult());
       }
-
-      TestCompletionCallback callback;
-      for (;;) {
-        scoped_refptr<IOBufferWithSize> buf = new IOBufferWithSize(4);
-        rv = stream_->Read(buf.get(), buf->size(), callback.callback());
-        if (rv == ERR_IO_PENDING) {
-          base::MessageLoop::ScopedNestableTaskAllower allow(
-              base::MessageLoop::current());
-          rv = callback.WaitForResult();
-        }
-        EXPECT_LE(0, rv);
-        if (rv <= 0)
-          break;
-        *total_bytes_read_ += rv;
-        data_read_->append(buf->data(), rv);
-      }
     }
 
     result_ = *total_bytes_written_;
     have_result_ = true;
     if (waiting_for_result_)
       base::MessageLoop::current()->Quit();
   }
 
   int result_;
   bool have_result_;
@@ skipping 33 matching lines @@
   TestWriteReadCompletionCallback callback(stream.get(), &total_bytes_written,
                                            &total_bytes_read, &data_read);
 
   scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
   rv = stream->Write(buf.get(), buf->size(), callback.callback());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_LT(0, rv);
   EXPECT_EQ(kTestDataSize, total_bytes_written);
 
+  callback.ValidateWrittenData();
+
   stream.reset();
 
   EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
   EXPECT_EQ(kTestDataSize * 2, file_size);
 
   EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
   const std::string kExpectedFileData =
       std::string(kTestData) + std::string(kTestData);
   EXPECT_EQ(kExpectedFileData, data_read);
 }
@@ skipping 215 matching lines @@
     total_bytes_read += rv;
     data_read.append(buf->data(), rv);
   }
   EXPECT_EQ(file_size, total_bytes_read);
 }
 #endif
 
 }  // namespace
 
 }  // namespace net