Reland https://codereview.chromium.org/1271593002/ which was reverted

net/url_request/url_request_simple_job_unittest.cc

 // Copyright 2014 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 "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
@@ skipping 47 matching lines @@
  private:
   ~MockSimpleJob() override {}
 
   const std::string data_;
 
   scoped_refptr<base::TaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSimpleJob);
 };
 
-class CancelURLRequestDelegate : public URLRequest::Delegate {
+class CancelAfterFirstReadURLRequestDelegate : public TestDelegate {
  public:
-  CancelURLRequestDelegate()
-      : buf_(new IOBuffer(kBufferSize)), run_loop_(new base::RunLoop) {}
+  CancelAfterFirstReadURLRequestDelegate() : run_loop_(new base::RunLoop) {}
+
+  ~CancelAfterFirstReadURLRequestDelegate() override {}
 
   void OnResponseStarted(URLRequest* request) override {
-    int bytes_read = 0;
-    EXPECT_FALSE(request->Read(buf_.get(), kBufferSize, &bytes_read));
-    EXPECT_TRUE(request->status().is_io_pending());
+    // net::TestDelegate will start the first read.
+    TestDelegate::OnResponseStarted(request);
     request->Cancel();
     run_loop_->Quit();
   }
 
-  void OnReadCompleted(URLRequest* request, int bytes_read) override {}
+  void OnReadCompleted(URLRequest* request, int bytes_read) override {
+    // Read should have been cancelled.
+    EXPECT_EQ(-1, bytes_read);
+  }
 
   void WaitUntilHeadersReceived() const { run_loop_->Run(); }
 
  private:
-  static const int kBufferSize = 4096;
-  scoped_refptr<IOBuffer> buf_;
   scoped_ptr<base::RunLoop> run_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(CancelAfterFirstReadURLRequestDelegate);
 };
 
 class SimpleJobProtocolHandler :
     public URLRequestJobFactory::ProtocolHandler {
  public:
   SimpleJobProtocolHandler(scoped_refptr<base::TaskRunner> task_runner)
       : task_runner_(task_runner) {}
   URLRequestJob* MaybeCreateJob(
       URLRequest* request,
       NetworkDelegate* network_delegate) const override {
@@ skipping 102 matching lines @@
 }
 
 TEST_F(URLRequestSimpleJobTest, EmptyDataRequest) {
   request_ =
       context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY, &delegate_);
   StartRequest(nullptr);
   ASSERT_TRUE(request_->status().is_success());
   EXPECT_EQ("", delegate_.data_received());
 }
 
-TEST_F(URLRequestSimpleJobTest, CancelAfterFirstRead) {
-  scoped_ptr<CancelURLRequestDelegate> cancel_delegate(
-      new CancelURLRequestDelegate());
+TEST_F(URLRequestSimpleJobTest, CancelBeforeResponseStarts) {
+  request_ =
+      context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY, &delegate_);
+  request_->Start();
+  request_->Cancel();
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(URLRequestStatus::CANCELED, request_->status().status());
+  EXPECT_EQ(1, delegate_.response_started_count());
+}
+
+TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) {
+  CancelAfterFirstReadURLRequestDelegate cancel_delegate;
   request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
-                                    cancel_delegate.get());
+                                    &cancel_delegate);
   request_->Start();
-  cancel_delegate->WaitUntilHeadersReceived();
+  cancel_delegate.WaitUntilHeadersReceived();
 
   // Feed a dummy task to the SequencedTaskRunner to make sure that the
   // callbacks which are invoked in ReadRawData have completed safely.
   base::RunLoop run_loop;
   EXPECT_TRUE(task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure()));
   run_loop.Run();
+
+  EXPECT_EQ(URLRequestStatus::CANCELED, request_->status().status());
+  EXPECT_EQ(1, cancel_delegate.response_started_count());
+  EXPECT_EQ("", cancel_delegate.data_received());
+  // Destroy the request so it doesn't outlive its delegate.
+  request_.reset();
 }
 
 }  // namespace net