ResourceLoader: Fix a bunch of double-cancellation/double-error notification cases.

content/browser/loader/intercepting_resource_handler_unittest.cc

 // 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.
 
 #include "content/browser/loader/intercepting_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 215 matching lines @@
                                           true,     // is_main_frame
                                           false,    // parent_is_main_frame
                                           true,     // allow_download
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   net::URLRequestStatus old_handler_status;
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler_scoped(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
+  // When sending a payload to the old ResourceHandler, the
+  // InterceptingResourceHandler doesn't send a final EOF read.
+  // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
+  // entirely?
+  old_handler_scoped->set_expect_eof_read(false);
   TestResourceHandler* old_handler = old_handler_scoped.get();
   scoped_refptr<net::IOBuffer> old_buffer = old_handler->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler_scoped),
                                       request.get()));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
   scoped_refptr<net::IOBuffer> read_buffer;
@@ skipping 347 matching lines @@
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   std::unique_ptr<TestResourceController> resource_controller =
       base::MakeUnique<TestResourceController>();
   net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
+  // When sending a payload to the old ResourceHandler, the
+  // InterceptingResourceHandler doesn't send a final EOF read.
+  // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
+  // entirely?
+  old_handler->set_expect_eof_read(false);
   old_handler->SetBufferSize(10);
   old_handler->set_defer_on_read_completed(true);
 
   scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
   intercepting_handler->SetController(resource_controller.get());
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 
@@ skipping 67 matching lines @@
   EXPECT_EQ("T", new_handler_body);
 
   intercepting_handler->Resume();
   EXPECT_EQ(2, resource_controller->resume_calls());
   EXPECT_EQ(kPayload, old_handler_body);
   EXPECT_EQ(kData, new_handler_body);
 
   EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
   EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
 
+  // Final EOF byte is read.
+  ASSERT_TRUE(intercepting_handler->OnReadCompleted(0, &defer));
+  ASSERT_FALSE(defer);
+
   defer = false;
   intercepting_handler->OnResponseCompleted({net::URLRequestStatus::SUCCESS, 0},
                                             &defer);
   ASSERT_TRUE(defer);
   EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
   EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::SUCCESS);
 }
 
 // Test cancellation where there is only the old handler in an
 // InterceptingResourceHandler.
@@ skipping 53 matching lines @@
                                           true,     // is_async
                                           false);   // is_using_lofi
 
   std::unique_ptr<TestResourceController> resource_controller =
       base::MakeUnique<TestResourceController>();
   net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
   std::string old_handler_body;
   std::unique_ptr<TestResourceHandler> old_handler(
       new TestResourceHandler(&old_handler_status, &old_handler_body));
+  // When sending a payload to the old ResourceHandler, the
+  // InterceptingResourceHandler doesn't send a final EOF read.
+  // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
+  // entirely?
+  old_handler->set_expect_eof_read(false);
 
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(std::move(old_handler), request.get()));
   intercepting_handler->SetController(resource_controller.get());
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
   scoped_refptr<net::IOBuffer> read_buffer;
   int buf_size = 0;
@@ skipping 106 matching lines @@
       {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
   ASSERT_TRUE(defer);
   EXPECT_EQ(0, resource_controller->resume_calls());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
 }
 
 }  // namespace
 
 }  // namespace content