Remove more unnecessary ChromeURLRequestContext members.

chrome/browser/renderer_host/offline_resource_handler.cc

 // Copyright (c) 2011 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 "chrome/browser/renderer_host/offline_resource_handler.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "chrome/browser/chromeos/network_state_notifier.h"
 #include "chrome/browser/chromeos/offline/offline_load_page.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/common/url_constants.h"
+#include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 OfflineResourceHandler::OfflineResourceHandler(
     ResourceHandler* handler,
     int host_id,
     int route_id,
     ResourceDispatcherHost* rdh,
-    net::URLRequest* request)
+    net::URLRequest* request,
+    ChromeAppCacheService* appcache_service)
     : next_handler_(handler),
       process_host_id_(host_id),
       render_view_id_(route_id),
       rdh_(rdh),
       request_(request),
+      appcache_service_(appcache_service),
       deferred_request_id_(-1) {
+  DCHECK(appcache_service_);
 }
 
 OfflineResourceHandler::~OfflineResourceHandler() {
   DCHECK(!appcache_completion_callback_.get());
 }
 
 bool OfflineResourceHandler::OnUploadProgress(int request_id,
-                                               uint64 position,
-                                               uint64 size) {
+                                              uint64 position,
+                                              uint64 size) {
   return next_handler_->OnUploadProgress(request_id, position, size);
 }
 
 bool OfflineResourceHandler::OnRequestRedirected(int request_id,
                                                  const GURL& new_url,
                                                  ResourceResponse* response,
                                                  bool* defer) {
   return next_handler_->OnRequestRedirected(
       request_id, new_url, response, defer);
 }
@@ skipping 45 matching lines @@
   if (ShouldShowOfflinePage(url)) {
     deferred_request_id_ = request_id;
     deferred_url_ = url;
     DVLOG(1) << "OnWillStart: this=" << this << ", request id=" << request_id
              << ", url=" << url;
     AddRef();  //  Balanced with OnCanHandleOfflineComplete
     DCHECK(!appcache_completion_callback_);
     appcache_completion_callback_ =
         new net::CancelableCompletionCallback<OfflineResourceHandler>(
             this, &OfflineResourceHandler::OnCanHandleOfflineComplete);
-    const ChromeURLRequestContext* url_request_context =
-        static_cast<const ChromeURLRequestContext*>(request_->context());
-    url_request_context->appcache_service()->CanHandleMainResourceOffline(
+    appcache_service_->CanHandleMainResourceOffline(
         url, appcache_completion_callback_);
 
     *defer = true;
     return true;
   }
   return next_handler_->OnWillStart(request_id, url, defer);
 }
 
 // We'll let the original event handler provide a buffer, and reuse it for
 // subsequent reads until we're done buffering.
@@ skipping 60 matching lines @@
   DVLOG(1) << "Resume load: this=" << this << ", request id=" << request_id;
   next_handler_->OnWillStart(request_id, url, &defer);
   if (!defer)
     rdh_->StartDeferredRequest(process_host_id_, request_id);
 }
 
 void OfflineResourceHandler::ShowOfflinePage() {
   chromeos::OfflineLoadPage::Show(
       process_host_id_, render_view_id_, deferred_url_, this);
 }