Remove URLRequestJob::GetResponseCode implementations.

headless/public/util/generic_url_request_job_test.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 "headless/public/util/generic_url_request_job.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 73 matching lines @@
 
     // Return the canned response.
     std::unique_ptr<base::Value> fetch_reply(
         base::JSONReader::Read(find_it->second, base::JSON_PARSE_RFC));
     CHECK(fetch_reply) << "Invalid json: " << find_it->second;
 
     base::DictionaryValue* reply_dictionary;
     ASSERT_TRUE(fetch_reply->GetAsDictionary(&reply_dictionary));
     std::string final_url;
     ASSERT_TRUE(reply_dictionary->GetString("url", &final_url));
-    int http_response_code;
-    ASSERT_TRUE(reply_dictionary->GetInteger("http_response_code",
-                                             &http_response_code));
     ASSERT_TRUE(reply_dictionary->GetString("data", &response_data_));
     base::DictionaryValue* reply_headers_dictionary;
     ASSERT_TRUE(
         reply_dictionary->GetDictionary("headers", &reply_headers_dictionary));
     scoped_refptr<net::HttpResponseHeaders> response_headers(
         new net::HttpResponseHeaders(""));
     for (base::DictionaryValue::Iterator it(*reply_headers_dictionary);
          !it.IsAtEnd(); it.Advance()) {
       std::string value;
       ASSERT_TRUE(it.value().GetAsString(&value));
       response_headers->AddHeader(
           base::StringPrintf("%s: %s", it.key().c_str(), value.c_str()));
     }
 
     result_listener->OnFetchComplete(
-        GURL(final_url), http_response_code, std::move(response_headers),
-        response_data_.c_str(), response_data_.size());
+        GURL(final_url), std::move(response_headers), response_data_.c_str(),
+        response_data_.size());
   }
 
  private:
   std::map<std::string, std::string>* json_fetch_reply_map_;  // NOT OWNED
   base::DictionaryValue* fetch_request_;  // NOT OWNED
   std::string response_data_;  // Here to ensure the required lifetime.
 };
 
 class MockProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
  public:
@@ skipping 62 matching lines @@
   base::DictionaryValue fetch_request_;  // The request sent to MockFetcher.
   std::map<std::string, std::string>
       json_fetch_reply_map_;  // Replies to be sent by MockFetcher.
   MockDelegate job_delegate_;
 };
 
 TEST_F(GenericURLRequestJobTest, BasicGetRequestParams) {
   json_fetch_reply_map_["https://example.com/"] = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(url_request_context_.CreateRequest(
       GURL("https://example.com"), net::DEFAULT_PRIORITY, &request_delegate_));
   request->SetReferrer("https://referrer.example.com");
   request->SetExtraRequestHeaderByName("Extra-Header", "Value", true);
@@ skipping 15 matching lines @@
         }
       })";
 
   EXPECT_THAT(fetch_request_, MatchesJson(expected_request_json));
 }
 
 TEST_F(GenericURLRequestJobTest, BasicPostRequestParams) {
   json_fetch_reply_map_["https://example.com/"] = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(url_request_context_.CreateRequest(
       GURL("https://example.com"), net::DEFAULT_PRIORITY, &request_delegate_));
   request->SetReferrer("https://referrer.example.com");
   request->SetExtraRequestHeaderByName("Extra-Header", "Value", true);
@@ skipping 23 matching lines @@
         }
       })";
 
   EXPECT_THAT(fetch_request_, MatchesJson(expected_request_json));
 }
 
 TEST_F(GenericURLRequestJobTest, BasicRequestProperties) {
   std::string reply = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(
       CreateAndCompleteGetJob(GURL("https://example.com"), reply));
 
   EXPECT_EQ(200, request->GetResponseCode());
 
   std::string mime_type;
   request->GetMimeType(&mime_type);
   EXPECT_EQ("text/html", mime_type);
 
   std::string charset;
   request->GetCharset(&charset);
   EXPECT_EQ("utf-8", charset);
 
   std::string content_type;
   EXPECT_TRUE(request->response_info().headers->GetNormalizedHeader(
       "Content-Type", &content_type));
   EXPECT_EQ("text/html; charset=UTF-8", content_type);
 }
 
 TEST_F(GenericURLRequestJobTest, BasicRequestContents) {
   std::string reply = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(
       CreateAndCompleteGetJob(GURL("https://example.com"), reply));
 
   const int kBufferSize = 256;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   int bytes_read;
   EXPECT_TRUE(request->Read(buffer.get(), kBufferSize, &bytes_read));
   EXPECT_EQ(5, bytes_read);
   EXPECT_EQ("Reply", std::string(buffer->data(), 5));
 
   net::LoadTimingInfo load_timing_info;
   request->GetLoadTimingInfo(&load_timing_info);
   EXPECT_FALSE(load_timing_info.receive_headers_end.is_null());
 }
 
 TEST_F(GenericURLRequestJobTest, ReadInParts) {
   std::string reply = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(
       CreateAndCompleteGetJob(GURL("https://example.com"), reply));
 
   const int kBufferSize = 3;
@@ skipping 66 matching lines @@
   cookies->push_back(*net::CanonicalCookie::Create(
       GURL("https://example.com"), "bad_path_cookie", "7", "example.com",
       "/gadgets", base::Time(), base::Time(),
       /* secure */ false,
       /* http_only */ false, net::CookieSameSite::NO_RESTRICTION,
       net::COOKIE_PRIORITY_DEFAULT));
 
   std::string reply = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(
       CreateAndCompleteGetJob(GURL("https://example.com"), reply));
 
   std::string expected_request_json = R"(
       {
         "url": "https://example.com/",
         "method": "GET",
         "headers": {
           "Cookie": "basic_cookie=1; secure_cookie=2; http_only_cookie=3",
           "Referer": ""
         }
       })";
 
   EXPECT_THAT(fetch_request_, MatchesJson(expected_request_json));
 }
 
 TEST_F(GenericURLRequestJobTest, DelegateBlocksLoading) {
   std::string reply = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   job_delegate_.SetPolicy(base::Bind([](PendingRequest* pending_request) {
     pending_request->BlockRequest(net::ERR_FILE_NOT_FOUND);
   }));
 
   std::unique_ptr<net::URLRequest> request(
       CreateAndCompleteGetJob(GURL("https://example.com"), reply));
 
   EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request->status().error());
 }
 
 TEST_F(GenericURLRequestJobTest, DelegateModifiesRequest) {
   json_fetch_reply_map_["https://example.com/"] = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Welcome to example.com",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   json_fetch_reply_map_["https://othersite.com/"] = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Welcome to othersite.com",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   // Turn the GET into a POST to a different site.
   job_delegate_.SetPolicy(base::Bind([](PendingRequest* pending_request) {
     net::HttpRequestHeaders headers;
     headers.SetHeader("TestHeader", "Hello");
@@ skipping 29 matching lines @@
   EXPECT_TRUE(request->Read(buffer.get(), kBufferSize, &bytes_read));
   EXPECT_EQ(24, bytes_read);
   EXPECT_EQ("Welcome to othersite.com",
             std::string(buffer->data(), bytes_read));
 }
 
 TEST_F(GenericURLRequestJobTest, DelegateMocks404Response) {
   std::string reply = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Reply",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   job_delegate_.SetPolicy(base::Bind([](PendingRequest* pending_request) {
     std::unique_ptr<GenericURLRequestJob::MockResponseData> mock_response_data(
         new GenericURLRequestJob::MockResponseData());
-    mock_response_data->http_response_code = 404;
     mock_response_data->response_data = "HTTP/1.1 404 Not Found\r\n\r\n";
     pending_request->MockResponse(std::move(mock_response_data));
   }));
 
   std::unique_ptr<net::URLRequest> request(
       CreateAndCompleteGetJob(GURL("https://example.com"), reply));
 
   EXPECT_EQ(404, request->GetResponseCode());
 }
 
 TEST_F(GenericURLRequestJobTest, DelegateMocks302Response) {
   job_delegate_.SetPolicy(base::Bind([](PendingRequest* pending_request) {
     if (pending_request->GetRequest()->GetURLRequest()->url().spec() ==
         "https://example.com/") {
       std::unique_ptr<GenericURLRequestJob::MockResponseData>
           mock_response_data(new GenericURLRequestJob::MockResponseData());
-      mock_response_data->http_response_code = 302;
       mock_response_data->response_data =
           "HTTP/1.1 302 Found\r\n"
           "Location: https://foo.com/\r\n\r\n";
       pending_request->MockResponse(std::move(mock_response_data));
     } else {
       pending_request->AllowRequest();
     }
   }));
 
   json_fetch_reply_map_["https://example.com/"] = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Welcome to example.com",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   json_fetch_reply_map_["https://foo.com/"] = R"(
       {
         "url": "https://example.com",
-        "http_response_code": 200,
         "data": "Welcome to foo.com",
         "headers": {
           "Content-Type": "text/html; charset=UTF-8"
         }
       })";
 
   std::unique_ptr<net::URLRequest> request(url_request_context_.CreateRequest(
       GURL("https://example.com"), net::DEFAULT_PRIORITY, &request_delegate_));
   request->Start();
   base::RunLoop().RunUntilIdle();
@@ skipping 14 matching lines @@
               OnResourceLoadFailed(_, net::ERR_ADDRESS_UNREACHABLE));
 
   std::unique_ptr<net::URLRequest> request(url_request_context_.CreateRequest(
       GURL("https://i-dont-exist.com"), net::DEFAULT_PRIORITY,
       &request_delegate_));
   request->Start();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace headless