net: Remove typedef net::URLRequest URLRequest;

webkit/appcache/appcache_request_handler.cc

 // Copyright (c) 2010 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 "webkit/appcache/appcache_request_handler.h"
 
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_url_request_job.h"
@@ skipping 23 matching lines @@
 
 void AppCacheRequestHandler::GetExtraResponseInfo(
     int64* cache_id, GURL* manifest_url) {
   if (job_ && job_->is_delivering_appcache_response()) {
     *cache_id = job_->cache_id();
     *manifest_url = job_->manifest_url();
   }
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource(
-    URLRequest* request) {
+    net::URLRequest* request) {
   if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_)
     return NULL;
 
   // This method can get called multiple times over the life
   // of a request. The case we detect here is having scheduled
   // delivery of a "network response" using a job setup on an
   // earlier call thru this method. To send the request thru
   // to the network involves restarting the request altogether,
   // which will call thru to our interception layer again.
   // This time thru, we return NULL so the request hits the wire.
@@ skipping 24 matching lines @@
   // have been started yet.
   if (job_ && job_->is_delivering_network_response()) {
     DCHECK(!job_->has_been_started());
     job_ = NULL;
   }
 
   return job_;
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
-    URLRequest* request, const GURL& location) {
+    net::URLRequest* request, const GURL& location) {
   if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_)
     return NULL;
   if (is_main_resource())
     return NULL;
   if (request->url().GetOrigin() == location.GetOrigin())
     return NULL;
 
   DCHECK(!job_);  // our jobs never generate redirects
 
   if (found_fallback_entry_.has_response_id()) {
     // 6.9.6, step 4: If this results in a redirect to another origin,
     // get the resource of the fallback entry.
     job_ = new AppCacheURLRequestJob(request, storage());
     DeliverAppCachedResponse(
         found_fallback_entry_, found_cache_id_, found_manifest_url_,
         true, found_fallback_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
     job_ = new AppCacheURLRequestJob(request, storage());
     DeliverErrorResponse();
   } else {
     // 6.9.6 step 3 and 5: Fetch the resource normally.
   }
 
   return job_;
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
-    URLRequest* request) {
+    net::URLRequest* request) {
   if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_)
     return NULL;
   if (!found_fallback_entry_.has_response_id())
     return NULL;
 
   if (request->status().status() == URLRequestStatus::CANCELED ||
       request->status().status() == URLRequestStatus::HANDLED_EXTERNALLY) {
     // 6.9.6, step 4: But not if the user canceled the download.
     return NULL;
   }
@@ skipping 50 matching lines @@
   job_->DeliverErrorResponse();
 }
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
   DCHECK(job_ && job_->is_waiting());
   job_->DeliverNetworkResponse();
 }
 
 // Main-resource handling ----------------------------------------------
 
-void AppCacheRequestHandler::MaybeLoadMainResource(URLRequest* request) {
+void AppCacheRequestHandler::MaybeLoadMainResource(net::URLRequest* request) {
   DCHECK(!job_);
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
   job_ = new AppCacheURLRequestJob(request, storage());
   storage()->FindResponseForMainRequest(request->url(), this);
 }
 
 void AppCacheRequestHandler::OnMainResponseFound(
     const GURL& url, const AppCacheEntry& entry,
@@ skipping 37 matching lines @@
         found_entry_, found_cache_id_, found_manifest_url_,
         false, GURL());
   } else {
     DeliverNetworkResponse();
   }
 }
 
 // Sub-resource handling ----------------------------------------------
 
 void AppCacheRequestHandler::MaybeLoadSubResource(
-    URLRequest* request) {
+    net::URLRequest* request) {
   DCHECK(!job_);
 
   if (host_->is_selection_pending()) {
     // We have to wait until cache selection is complete and the
     // selected cache is loaded.
     is_waiting_for_cache_selection_ = true;
     job_ = new AppCacheURLRequestJob(request, storage());
     return;
   }
 
@@ skipping 67 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache