Remove URLRequestJob::GetResponseCode implementations.

components/domain_reliability/uploader_unittest.cc

 // Copyright 2015 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 "components/domain_reliability/uploader.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 15 matching lines @@
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace domain_reliability {
 namespace {
 
 const char kUploadURL[] = "https://example/upload";
 
 struct MockUploadResult {
   int net_error;
-  int response_code;
   scoped_refptr<net::HttpResponseHeaders> response_headers;
 };
 
 class UploadMockURLRequestJob : public net::URLRequestJob {
  public:
   UploadMockURLRequestJob(net::URLRequest* request,
                           net::NetworkDelegate* network_delegate,
                           MockUploadResult result)
       : net::URLRequestJob(request, network_delegate),
         upload_stream_(nullptr),
@@ skipping 41 matching lines @@
 
     upload_data_ = std::string(upload_buffer_->data(), upload_buffer_->size());
     upload_buffer_ = nullptr;
 
     if (result_.net_error == net::OK)
       NotifyHeadersComplete();
     else if (result_.net_error != net::ERR_IO_PENDING)
       NotifyStartError(net::URLRequestStatus::FromError(result_.net_error));
   }
 
-  int GetResponseCode() const override {
-    return result_.response_code;
-  }
-
   void GetResponseInfo(net::HttpResponseInfo* info) override {
     info->headers = result_.response_headers;
   }
 
   net::UploadDataStream* upload_stream_;
   scoped_refptr<net::IOBufferWithSize> upload_buffer_;
   std::string upload_data_;
   MockUploadResult result_;
 };
 
@@ skipping 16 matching lines @@
         DomainReliabilityUploader::GetURLRequestUploadDepth(*request);
 
     ++request_count_;
 
     return new UploadMockURLRequestJob(request, delegate, result);
   }
 
   void ExpectRequestAndReturnError(int net_error) {
     MockUploadResult result;
     result.net_error = net_error;
-    result.response_code = -1;
     results_.push_back(result);
   }
 
-  void ExpectRequestAndReturnResponseCode(int response_code) {
+  void ExpectRequestAndReturnResponseHeaders(const char* headers) {
     MockUploadResult result;
     result.net_error = net::OK;
-    result.response_code = response_code;
-    results_.push_back(result);
-  }
-
-  void ExpectRequestAndReturnResponseCodeAndHeaders(
-      int response_code,
-      const char* headers) {
-    MockUploadResult result;
-    result.net_error = net::OK;
-    result.response_code = response_code;
     result.response_headers = new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(headers, strlen(headers)));
     results_.push_back(result);
   }
 
   int request_count() const { return request_count_; }
   int last_upload_depth() const { return last_upload_depth_; }
 
  private:
   mutable std::list<MockUploadResult> results_;
@@ skipping 54 matching lines @@
   UploadInterceptor* interceptor_;
   MockTime time_;
   std::unique_ptr<DomainReliabilityUploader> uploader_;
 };
 
 TEST_F(DomainReliabilityUploaderTest, Null) {
   uploader()->Shutdown();
 }
 
 TEST_F(DomainReliabilityUploaderTest, SuccessfulUpload) {
-  interceptor()->ExpectRequestAndReturnResponseCode(200);
+  interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 200\r\n\r\n");
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 0, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
   EXPECT_TRUE(c.last_result().is_success());
 
   uploader()->Shutdown();
 }
 
 TEST_F(DomainReliabilityUploaderTest, NetworkErrorUpload) {
   interceptor()->ExpectRequestAndReturnError(net::ERR_CONNECTION_REFUSED);
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 0, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
   EXPECT_TRUE(c.last_result().is_failure());
 
   uploader()->Shutdown();
 }
 
 TEST_F(DomainReliabilityUploaderTest, ServerErrorUpload) {
-  interceptor()->ExpectRequestAndReturnResponseCode(500);
+  interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 500\r\n\r\n");
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 0, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
   EXPECT_TRUE(c.last_result().is_failure());
 
   uploader()->Shutdown();
 }
 
 TEST_F(DomainReliabilityUploaderTest, RetryAfterUpload) {
-  interceptor()->ExpectRequestAndReturnResponseCodeAndHeaders(
-      503,
+  interceptor()->ExpectRequestAndReturnResponseHeaders(
       "HTTP/1.1 503 Ugh\nRetry-After: 3600\n\n");
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 0, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
   EXPECT_TRUE(c.last_result().is_retry_after());
 
   uploader()->Shutdown();
 }
 
 TEST_F(DomainReliabilityUploaderTest, UploadDepth1) {
-  interceptor()->ExpectRequestAndReturnResponseCode(200);
+  interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 200\r\n\r\n");
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 0, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
 
   EXPECT_EQ(1, interceptor()->last_upload_depth());
 
   uploader()->Shutdown();
 }
 
 TEST_F(DomainReliabilityUploaderTest, UploadDepth2) {
-  interceptor()->ExpectRequestAndReturnResponseCode(200);
+  interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 200\r\n\r\n");
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 1, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
 
   EXPECT_EQ(2, interceptor()->last_upload_depth());
 
   uploader()->Shutdown();
 }
@@ skipping 19 matching lines @@
 
   TestUploadCallback c;
   uploader()->UploadReport("{}", 1, GURL(kUploadURL), c.callback());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, c.called_count());
   EXPECT_EQ(0, interceptor()->request_count());
 }
 
 }  // namespace
 }  // namespace domain_reliability