Avoid issuing a Read() after draining a request.

content/browser/loader/resource_loader_unittest.cc

 // Copyright (c) 2013 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 "content/browser/loader/resource_loader.h"
 
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/platform_file.h"
@@ skipping 74 matching lines @@
 // initialize ResourceLoader.
 class ResourceHandlerStub : public ResourceHandler {
  public:
   explicit ResourceHandlerStub(net::URLRequest* request)
       : ResourceHandler(request),
         read_buffer_(new net::IOBuffer(kReadBufSize)),
         defer_request_on_will_start_(false),
         expect_reads_(true),
         cancel_on_read_completed_(false),
         defer_eof_(false),
+        received_on_will_read_(false),
+        received_eof_(false),
         received_response_completed_(false),
         total_bytes_downloaded_(0) {
   }
 
   // If true, defers the resource load in OnWillStart.
   void set_defer_request_on_will_start(bool defer_request_on_will_start) {
     defer_request_on_will_start_ = defer_request_on_will_start;
   }
 
   // If true, expect OnWillRead / OnReadCompleted pairs for handling
@@ skipping 56 matching lines @@
   virtual bool OnBeforeNetworkStart(int request_id,
                                     const GURL& url,
                                     bool* defer) OVERRIDE {
     return true;
   }
 
   virtual bool OnWillRead(int request_id,
                           scoped_refptr<net::IOBuffer>* buf,
                           int* buf_size,
                           int min_size) OVERRIDE {
-    if (!expect_reads_) {
-      ADD_FAILURE();
-      return false;
-    }
+    EXPECT_TRUE(expect_reads_);
+    EXPECT_FALSE(received_on_will_read_);
+    EXPECT_FALSE(received_eof_);
+    EXPECT_FALSE(received_response_completed_);
 
     *buf = read_buffer_;
     *buf_size = kReadBufSize;
+    received_on_will_read_ = true;
     return true;
   }
 
   virtual bool OnReadCompleted(int request_id,
                                int bytes_read,
                                bool* defer) OVERRIDE {
-    if (!expect_reads_) {
-      ADD_FAILURE();
-      return false;
+    EXPECT_TRUE(received_on_will_read_);
+    EXPECT_TRUE(expect_reads_);
+    EXPECT_FALSE(received_response_completed_);
+
+    if (bytes_read == 0) {
+      received_eof_ = true;
+      if (defer_eof_) {
+        defer_eof_ = false;
+        *defer = true;
+      }
     }
 
-    if (bytes_read == 0 && defer_eof_) {
-      // Only defer it once; on resumption there will be another EOF.
-      defer_eof_ = false;
-      *defer = true;
-    }
+    // Need another OnWillRead() call before seeing an OnReadCompleted().
+    received_on_will_read_ = false;
 
     return !cancel_on_read_completed_;
   }
 
   virtual void OnResponseCompleted(int request_id,
                                    const net::URLRequestStatus& status,
                                    const std::string& security_info,
                                    bool* defer) OVERRIDE {
     EXPECT_FALSE(received_response_completed_);
+    if (status.is_success() && expect_reads_)
+      EXPECT_TRUE(received_eof_);
+
     received_response_completed_ = true;
     status_ = status;
   }
 
   virtual void OnDataDownloaded(int request_id,
                                 int bytes_downloaded) OVERRIDE {
-    if (expect_reads_)
-      ADD_FAILURE();
+    EXPECT_FALSE(expect_reads_);
     total_bytes_downloaded_ += bytes_downloaded;
   }
 
  private:
   scoped_refptr<net::IOBuffer> read_buffer_;
 
   bool defer_request_on_will_start_;
   bool expect_reads_;
   bool cancel_on_read_completed_;
   bool defer_eof_;
 
   GURL start_url_;
   scoped_refptr<ResourceResponse> response_;
+  bool received_on_will_read_;
+  bool received_eof_;
   bool received_response_completed_;
   net::URLRequestStatus status_;
   int total_bytes_downloaded_;
 };
 
 // Test browser client that captures calls to SelectClientCertificates and
 // records the arguments of the most recent call for later inspection.
 class SelectCertificateBrowserClient : public TestContentBrowserClient {
  public:
   SelectCertificateBrowserClient() : call_count_(0) {}
@@ skipping 490 matching lines @@
   ASSERT_TRUE(base::ReadFileToString(temp_path(), &contents));
   EXPECT_EQ(test_data(), contents);
 
   // Release the loader. The file should be gone now.
   ReleaseLoader();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(base::PathExists(temp_path()));
 }
 
 }  // namespace content