Adjust callers and networking delegates in net/ to modified APIs

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 145 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_EQ(OK, delegate_.request_status());
   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_EQ(OK, delegate_.request_status());
   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_EQ(OK, delegate_.request_status());
   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_EQ(OK, delegate_.request_status());
   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_EQ(ERR_ABORTED, delegate_.request_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);
   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_EQ(1, cancel_delegate.response_started_count());

[mmenke, 2016/09/01 16:57:26]

Why can't we check if the request was cancelled?  cancel_delegate subclasses
TestDelegate, so it should have its status set, right?

[maksims (do not use this acc), 2016/09/02 12:31:53]

Well, cancel_delegate overrides the OnReadCompleted method and has a
EXPECT_EQ(ERR_ABORTED, bytes_read) there. But to make in more obvious, I've
removed this method from this subclass and check the status normally, because
TestDelegate::OnReadCompleted will now set the status.

   EXPECT_EQ("", cancel_delegate.data_received());
   // Destroy the request so it doesn't outlive its delegate.
   request_.reset();
 }
 
 }  // namespace net