Use modifed URLRequest API in net/url_request/url_request unittests

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 "net/url_request/url_request_simple_job.h"
 
 #include <memory>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 70 matching lines @@
   ~CancelAfterFirstReadURLRequestDelegate() override {}
 
   void OnResponseStarted(URLRequest* request, int net_error) override {
     DCHECK_NE(ERR_IO_PENDING, net_error);
     // net::TestDelegate will start the first read.
     TestDelegate::OnResponseStarted(request, net_error);
     request->Cancel();
     run_loop_->Quit();
   }
 
-  void OnReadCompleted(URLRequest* request, int bytes_read) override {
-    // Read should have been cancelled.
-    EXPECT_EQ(ERR_ABORTED, bytes_read);
-  }
-
   void WaitUntilHeadersReceived() const { run_loop_->Run(); }
 
  private:
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(CancelAfterFirstReadURLRequestDelegate);
 };
 
 class SimpleJobProtocolHandler :
     public URLRequestJobFactory::ProtocolHandler {
@@ skipping 50 matching lines @@
   TestURLRequestContext context_;
   URLRequestJobFactoryImpl job_factory_;
   TestDelegate delegate_;
   std::unique_ptr<URLRequest> request_;
 };
 
 }  // namespace
 
 TEST_F(URLRequestSimpleJobTest, SimpleRequest) {
   StartRequest(NULL);
-  ASSERT_TRUE(request_->status().is_success());
+  EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ(kTestData, delegate_.data_received());
 }
 
 TEST_F(URLRequestSimpleJobTest, RangeRequest) {
   const std::string kExpectedBody = std::string(
       kTestData + kRangeFirstPosition, kTestData + kRangeLastPosition + 1);
   HttpRequestHeaders headers;
   headers.SetHeader(
       HttpRequestHeaders::kRange,
       HttpByteRange::Bounded(kRangeFirstPosition, kRangeLastPosition)
           .GetHeaderValue());
 
   StartRequest(&headers);
 
-  ASSERT_TRUE(request_->status().is_success());
+  EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ(kExpectedBody, delegate_.data_received());
 }
 
 TEST_F(URLRequestSimpleJobTest, MultipleRangeRequest) {
   HttpRequestHeaders headers;
   int middle_pos = (kRangeFirstPosition + kRangeLastPosition)/2;
   std::string range = base::StringPrintf("bytes=%d-%d,%d-%d",
                                          kRangeFirstPosition,
                                          middle_pos,
                                          middle_pos + 1,
                                          kRangeLastPosition);
   headers.SetHeader(HttpRequestHeaders::kRange, range);
 
   StartRequest(&headers);
 
   EXPECT_TRUE(delegate_.request_failed());
-  EXPECT_THAT(request_->status().error(),
-              IsError(ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+  EXPECT_EQ(ERR_REQUEST_RANGE_NOT_SATISFIABLE, delegate_.request_status());
 }
 
 TEST_F(URLRequestSimpleJobTest, InvalidRangeRequest) {
   HttpRequestHeaders headers;
   std::string range = base::StringPrintf(
       "bytes=%d-%d", kRangeLastPosition, kRangeFirstPosition);
   headers.SetHeader(HttpRequestHeaders::kRange, range);
 
   StartRequest(&headers);
 
-  ASSERT_TRUE(request_->status().is_success());
+  EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ(kTestData, delegate_.data_received());
 }
 
 TEST_F(URLRequestSimpleJobTest, EmptyDataRequest) {
   request_ =
       context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY, &delegate_);
   StartRequest(nullptr);
-  ASSERT_TRUE(request_->status().is_success());
+  EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ("", delegate_.data_received());
 }
 
 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_THAT(delegate_.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(1, delegate_.response_started_count());
 }
 
 TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) {
   CancelAfterFirstReadURLRequestDelegate cancel_delegate;
   request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
                                     &cancel_delegate);
   request_->Start();
   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_THAT(cancel_delegate.request_status(), IsError(ERR_ABORTED));
   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