Remove URLRequestJob::GetResponseCode implementations from AppCache.

content/browser/appcache/appcache_request_handler_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 "content/browser/appcache/appcache_request_handler.h"
 
 #include <stdint.h>
 
 #include <stack>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/appcache/mock_appcache_policy.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
+#include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 static const int kMockProcessId = 1;
 
@@ skipping 55 matching lines @@
     int request_status() const { return request_status_; }
 
    private:
     int request_status_;
   };
 
   class MockURLRequestJob : public net::URLRequestJob {
    public:
     MockURLRequestJob(net::URLRequest* request,
                       net::NetworkDelegate* network_delegate,
-                      int response_code)
-        : net::URLRequestJob(request, network_delegate),
-          response_code_(response_code),
-          has_response_info_(false) {}
-    MockURLRequestJob(net::URLRequest* request,
-                      net::NetworkDelegate* network_delegate,
                       const net::HttpResponseInfo& info)
         : net::URLRequestJob(request, network_delegate),
-          response_code_(info.headers->response_code()),
           has_response_info_(true),
           response_info_(info) {}
 
     ~MockURLRequestJob() override {}
 
    protected:
     void Start() override { NotifyHeadersComplete(); }
-    int GetResponseCode() const override { return response_code_; }
     void GetResponseInfo(net::HttpResponseInfo* info) override {
       if (!has_response_info_)
         return;
       *info = response_info_;
     }
 
    private:
-    int response_code_;
     bool has_response_info_;
     net::HttpResponseInfo response_info_;
   };
 
   class MockURLRequestJobFactory : public net::URLRequestJobFactory {
    public:
     MockURLRequestJobFactory() {}
 
     ~MockURLRequestJobFactory() override { DCHECK(!job_); }
 
@@ skipping 247 matching lines @@
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void SimulateResponseCode(int response_code) {
+    net::HttpResponseInfo info;
+    std::string headers =
+        base::StringPrintf("HTTP/1.1 %i Muffin\r\n\r\n", response_code);
+    info.headers = new net::HttpResponseHeaders(
+        net::HttpUtil::AssembleRawHeaders(headers.c_str(), headers.length()));
+
     job_factory_->SetJob(base::MakeUnique<MockURLRequestJob>(
-        request_.get(), request_->context()->network_delegate(),
-        response_code));
+        request_.get(), request_->context()->network_delegate(), info));
     request_->Start();
-    // All our simulation needs  to satisfy are the following two DCHECKs
+    // All our simulation needs to satisfy are the following two DCHECKs.
     DCHECK_EQ(net::OK, delegate_.request_status());
     DCHECK_EQ(response_code, request_->GetResponseCode());
   }
 
   void SimulateResponseInfo(const net::HttpResponseInfo& info) {
     job_factory_->SetJob(base::MakeUnique<MockURLRequestJob>(
         request_.get(), request_->context()->network_delegate(), info));
     request_->Start();
   }
 
@@ skipping 707 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace content