net: Remove typedef net::URLRequest URLRequest;

chrome/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 139 matching lines @@
         NOTREACHED() << "Denied unauthorized upload of "
                      << iter->file_path().value();
         return false;
       }
     }
   }
 
   return true;
 }
 
-void PopulateResourceResponse(URLRequest* request,
+void PopulateResourceResponse(net::URLRequest* request,
                               bool replace_extension_localization_templates,
                               ResourceResponse* response) {
   response->response_head.status = request->status();
   response->response_head.request_time = request->request_time();
   response->response_head.response_time = request->response_time();
   response->response_head.headers = request->response_headers();
   request->GetCharset(&response->response_head.charset);
   response->response_head.replace_extension_localization_templates =
       replace_extension_localization_templates;
   response->response_head.content_length = request->GetExpectedContentSize();
@@ skipping 68 matching lines @@
       BrowserThread::IO, FROM_HERE,
       NewRunnableFunction(&appcache::AppCacheInterceptor::EnsureRegistered));
 }
 
 void ResourceDispatcherHost::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, new ShutdownTask(this));
 }
 
 void ResourceDispatcherHost::SetRequestInfo(
-    URLRequest* request,
+    net::URLRequest* request,
     ResourceDispatcherHostRequestInfo* info) {
   request->SetUserData(NULL, info);
 }
 
 void ResourceDispatcherHost::OnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   is_shutdown_ = true;
   resource_queue_.Shutdown();
   STLDeleteValues(&pending_requests_);
   // Make sure we shutdown the timer now, otherwise by the time our destructor
@@ skipping 18 matching lines @@
     CancelBlockedRequestsForRoute(iter->first, iter->second);
   }
 }
 
 bool ResourceDispatcherHost::HandleExternalProtocol(int request_id,
                                                     int child_id,
                                                     int route_id,
                                                     const GURL& url,
                                                     ResourceType::Type type,
                                                     ResourceHandler* handler) {
-  if (!ResourceType::IsFrame(type) || URLRequest::IsHandledURL(url))
+  if (!ResourceType::IsFrame(type) || net::URLRequest::IsHandledURL(url))
     return false;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableFunction(
           &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
 
   handler->OnResponseCompleted(request_id, URLRequestStatus(
                                                URLRequestStatus::FAILED,
                                                net::ERR_ABORTED),
@@ skipping 124 matching lines @@
   if (request_data.download_to_file)
     handler = new RedirectToFileResourceHandler(handler, child_id, this);
 
   if (HandleExternalProtocol(request_id, child_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
-  URLRequest* request = new URLRequest(request_data.url, this);
+  net::URLRequest* request = new net::URLRequest(request_data.url, this);
   request->set_method(request_data.method);
   request->set_first_party_for_cookies(request_data.first_party_for_cookies);
   request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kNoReferrers) ? std::string() : request_data.referrer.spec());
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(request_data.headers);
   request->SetExtraRequestHeaders(headers);
 
   int load_flags = request_data.load_flags;
   // Although EV status is irrelevant to sub-frames and sub-resources, we have
@@ skipping 256 matching lines @@
   if (!ChildProcessSecurityPolicy::GetInstance()->
           CanRequestURL(child_id, url)) {
     VLOG(1) << "Denied unauthorized download request for "
             << url.possibly_invalid_spec();
     return;
   }
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
   PluginService::GetInstance()->LoadChromePlugins(this);
-  URLRequest* request = new URLRequest(url, this);
+  net::URLRequest* request = new net::URLRequest(url, this);
 
   request_id_--;
 
   scoped_refptr<ResourceHandler> handler(
       new DownloadResourceHandler(this,
                                   child_id,
                                   route_id,
                                   request_id_,
                                   url,
                                   download_file_manager_.get(),
                                   request,
                                   prompt_for_save_location,
                                   save_info));
 
   if (safe_browsing_->enabled()) {
     handler = CreateSafeBrowsingResourceHandler(handler, child_id, route_id,
                                                 ResourceType::MAIN_FRAME);
   }
 
-  if (!URLRequest::IsHandledURL(url)) {
+  if (!net::URLRequest::IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     return;
   }
 
   request->set_method("GET");
   request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kNoReferrers) ? std::string() : referrer.spec());
   request->set_context(request_context);
   request->set_load_flags(request->load_flags() |
@@ skipping 20 matching lines @@
   // requests.  Does nothing if they are already loaded.
   PluginService::GetInstance()->LoadChromePlugins(this);
 
   scoped_refptr<ResourceHandler> handler(
       new SaveFileResourceHandler(child_id,
                                   route_id,
                                   url,
                                   save_file_manager_.get()));
   request_id_--;
 
-  bool known_proto = URLRequest::IsHandledURL(url);
+  bool known_proto = net::URLRequest::IsHandledURL(url);
   if (!known_proto) {
     // Since any URLs which have non-standard scheme have been filtered
     // by save manager(see GURL::SchemeIsStandard). This situation
     // should not happen.
     NOTREACHED();
     return;
   }
 
-  URLRequest* request = new URLRequest(url, this);
+  net::URLRequest* request = new net::URLRequest(url, this);
   request->set_method("GET");
   request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kNoReferrers) ? std::string() : referrer.spec());
   // So far, for saving page, we need fetch content from cache, in the
   // future, maybe we can use a configuration to configure this behavior.
   request->set_load_flags(net::LOAD_PREFERRING_CACHE);
   request->set_context(request_context);
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceDispatcherHostRequestInfo* extra_info =
@@ skipping 28 matching lines @@
   if (i == pending_requests_.end()) {
     // The request may have been destroyed
     LOG(WARNING) << "Trying to resume a non-existent request ("
                  << process_unique_id << ", " << request_id << ")";
     return;
   }
 
   // TODO(eroman): are there other considerations for paused or blocked
   //               requests?
 
-  URLRequest* request = i->second;
+  net::URLRequest* request = i->second;
   InsertIntoResourceQueue(request, *InfoForRequest(request));
 }
 
 bool ResourceDispatcherHost::WillSendData(int child_id,
                                           int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "WillSendData for invalid request";
     return false;
@@ skipping 80 matching lines @@
     }
   }
 
   // Remove matches.
   for (size_t i = 0; i < matching_requests.size(); ++i) {
     PendingRequestList::iterator iter =
         pending_requests_.find(matching_requests[i]);
     // Although every matching request was in pending_requests_ when we built
     // matching_requests, it is normal for a matching request to be not found
     // in pending_requests_ after we have removed some matching requests from
-    // pending_requests_.  For example, deleting a URLRequest that has
+    // pending_requests_.  For example, deleting a net::URLRequest that has
     // exclusive (write) access to an HTTP cache entry may unblock another
-    // URLRequest that needs exclusive access to the same cache entry, and
-    // that URLRequest may complete and remove itself from pending_requests_.
-    // So we need to check that iter is not equal to pending_requests_.end().
+    // net::URLRequest that needs exclusive access to the same cache entry, and
+    // that net::URLRequest may complete and remove itself from
+    // pending_requests_. So we need to check that iter is not equal to
+    // pending_requests_.end().
     if (iter != pending_requests_.end())
       RemovePendingRequest(iter);
   }
 
   // Now deal with blocked requests if any.
   if (route_id != -1) {
     if (blocked_requests_map_.find(std::pair<int, int>(child_id, route_id)) !=
         blocked_requests_map_.end()) {
       CancelBlockedRequestsForRoute(child_id, route_id);
     }
@@ skipping 44 matching lines @@
   resource_queue_.RemoveRequest(iter->first);
 
   delete iter->second;
   pending_requests_.erase(iter);
 
   // If we have no more pending requests, then stop the load state monitor
   if (pending_requests_.empty())
     update_load_states_timer_.Stop();
 }
 
-// URLRequest::Delegate -------------------------------------------------------
+// net::URLRequest::Delegate ---------------------------------------------------
 
-void ResourceDispatcherHost::OnReceivedRedirect(URLRequest* request,
+void ResourceDispatcherHost::OnReceivedRedirect(net::URLRequest* request,
                                                 const GURL& new_url,
                                                 bool* defer_redirect) {
   VLOG(1) << "OnReceivedRedirect: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   DCHECK(request->status().is_success());
 
   if (info->process_type() != ChildProcessInfo::PLUGIN_PROCESS &&
       !ChildProcessSecurityPolicy::GetInstance()->
           CanRequestURL(info->child_id(), new_url)) {
@@ skipping 18 matching lines @@
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   PopulateResourceResponse(request,
       info->replace_extension_localization_templates(), response);
   if (!info->resource_handler()->OnRequestRedirected(info->request_id(),
                                                      new_url,
                                                      response, defer_redirect))
     CancelRequestInternal(request, false);
 }
 
 void ResourceDispatcherHost::OnAuthRequired(
-    URLRequest* request,
+    net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
   // Create a login dialog on the UI thread to get authentication data,
   // or pull from cache and continue on the IO thread.
   // TODO(mpcomplete): We should block the parent tab while waiting for
   // authentication.
-  // That would also solve the problem of the URLRequest being cancelled
+  // That would also solve the problem of the net::URLRequest being cancelled
   // before we receive authentication.
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   DCHECK(!info->login_handler()) <<
       "OnAuthRequired called with login_handler pending";
   info->set_login_handler(CreateLoginPrompt(auth_info, request));
 }
 
 void ResourceDispatcherHost::OnCertificateRequested(
-    URLRequest* request,
+    net::URLRequest* request,
     net::SSLCertRequestInfo* cert_request_info) {
   DCHECK(request);
 
   if (cert_request_info->client_certs.empty()) {
     // No need to query the user if there are no certs to choose from.
     request->ContinueWithCertificate(NULL);
     return;
   }
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   DCHECK(!info->ssl_client_auth_handler()) <<
       "OnCertificateRequested called with ssl_client_auth_handler pending";
   info->set_ssl_client_auth_handler(
       new SSLClientAuthHandler(request, cert_request_info));
   info->ssl_client_auth_handler()->SelectCertificate();
 }
 
 void ResourceDispatcherHost::OnSSLCertificateError(
-    URLRequest* request,
+    net::URLRequest* request,
     int cert_error,
     net::X509Certificate* cert) {
   DCHECK(request);
   SSLManager::OnSSLCertificateError(this, request, cert_error, cert);
 }
 
-void ResourceDispatcherHost::OnSetCookie(URLRequest* request,
+void ResourceDispatcherHost::OnSetCookie(net::URLRequest* request,
                                          const std::string& cookie_line,
                                          const net::CookieOptions& options,
                                          bool blocked_by_policy) {
   VLOG(1) << "OnSetCookie: " << request->url().spec();
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
   CallRenderViewHostContentSettingsDelegate(
       render_process_id, render_view_id,
       &RenderViewHostDelegate::ContentSettings::OnCookieAccessed,
       request->url(), cookie_line, options, blocked_by_policy);
 }
 
-void ResourceDispatcherHost::OnResponseStarted(URLRequest* request) {
+void ResourceDispatcherHost::OnResponseStarted(net::URLRequest* request) {
   VLOG(1) << "OnResponseStarted: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (PauseRequestIfNeeded(info)) {
     VLOG(1) << "OnResponseStarted pausing: " << request->url().spec();
     return;
   }
 
   if (request->status().is_success()) {
     // We want to send a final upload progress message prior to sending
     // the response complete message even if we're waiting for an ack to
@@ skipping 10 matching lines @@
         return;
       }
 
       StartReading(request);
     }
   } else {
     OnResponseCompleted(request);
   }
 }
 
-bool ResourceDispatcherHost::CompleteResponseStarted(URLRequest* request) {
+bool ResourceDispatcherHost::CompleteResponseStarted(net::URLRequest* request) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   PopulateResourceResponse(request,
       info->replace_extension_localization_templates(), response);
 
   if (request->ssl_info().cert) {
     int cert_id =
         CertStore::GetSharedInstance()->StoreCert(request->ssl_info().cert,
                                                   info->child_id());
@@ skipping 23 matching lines @@
   if (i == pending_requests_.end()) {
     // We probably want to remove this warning eventually, but I wanted to be
     // able to notice when this happens during initial development since it
     // should be rare and may indicate a bug.
     DLOG(WARNING) << "Canceling a request that wasn't found";
     return;
   }
   CancelRequestInternal(i->second, from_renderer);
 }
 
-void ResourceDispatcherHost::CancelRequestInternal(URLRequest* request,
+void ResourceDispatcherHost::CancelRequestInternal(net::URLRequest* request,
                                                    bool from_renderer) {
   VLOG(1) << "CancelRequest: " << request->url().spec();
 
   // WebKit will send us a cancel for downloads since it no longer handles them.
   // In this case, ignore the cancel since we handle downloads in the browser.
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!from_renderer || !info->is_download()) {
     if (info->login_handler()) {
       info->login_handler()->OnRequestCancelled();
       info->set_login_handler(NULL);
@@ skipping 28 matching lines @@
   if (new_cost == 0)
     outstanding_requests_memory_cost_map_.erase(prev_entry);
   else
     outstanding_requests_memory_cost_map_[child_id] = new_cost;
 
   return new_cost;
 }
 
 // static
 int ResourceDispatcherHost::CalculateApproximateMemoryCost(
-    URLRequest* request) {
+    net::URLRequest* request) {
   // The following fields should be a minor size contribution (experimentally
   // on the order of 100). However since they are variable length, it could
   // in theory be a sizeable contribution.
   int strings_cost = request->extra_request_headers().ToString().size() +
                      request->original_url().spec().size() +
                      request->referrer().size() +
                      request->method().size();
 
   int upload_cost = 0;
 
@@ skipping 14 matching lines @@
       }
     }
   }
 #endif
 
   // Note that this expression will typically be dominated by:
   // |kAvgBytesPerOutstandingRequest|.
   return kAvgBytesPerOutstandingRequest + strings_cost + upload_cost;
 }
 
-void ResourceDispatcherHost::BeginRequestInternal(URLRequest* request) {
+void ResourceDispatcherHost::BeginRequestInternal(net::URLRequest* request) {
   DCHECK(!request->is_pending());
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   // Add the memory estimate that starting this request will consume.
   info->set_memory_cost(CalculateApproximateMemoryCost(request));
   int memory_cost = IncrementOutstandingRequestsMemoryCost(info->memory_cost(),
                                                            info->child_id());
 
   // If enqueing/starting this request will exceed our per-process memory
   // bound, abort it right away.
   if (memory_cost > max_outstanding_requests_cost_per_process_) {
-    // We call "SimulateError()" as a way of setting the URLRequest's
+    // We call "SimulateError()" as a way of setting the net::URLRequest's
     // status -- it has no effect beyond this, since the request hasn't started.
     request->SimulateError(net::ERR_INSUFFICIENT_RESOURCES);
 
     // TODO(eroman): this is kinda funky -- we insert the unstarted request into
     // |pending_requests_| simply to please OnResponseCompleted().
     GlobalRequestID global_id(info->child_id(), info->request_id());
     pending_requests_[global_id] = request;
     OnResponseCompleted(request);
     return;
   }
 
   std::pair<int, int> pair_id(info->child_id(), info->route_id());
   BlockedRequestMap::const_iterator iter = blocked_requests_map_.find(pair_id);
   if (iter != blocked_requests_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(request);
     return;
   }
 
   GlobalRequestID global_id(info->child_id(), info->request_id());
   pending_requests_[global_id] = request;
 
-  // Give the resource handlers an opportunity to delay the URLRequest from
+  // Give the resource handlers an opportunity to delay the net::URLRequest from
   // being started.
   //
   // There are three cases:
   //
   //   (1) if OnWillStart() returns false, the request is cancelled (regardless
   //       of whether |defer_start| was set).
   //   (2) If |defer_start| was set to true, then the request is not added
   //       into the resource queue, and will only be started in response to
   //       calling StartDeferredRequest().
   //   (3) If |defer_start| is not set, then the request is inserted into
   //       the resource_queue_ (which may pause it further, or start it).
   bool defer_start = false;
   if (!info->resource_handler()->OnWillStart(
           info->request_id(), request->url(),
           &defer_start)) {
     CancelRequestInternal(request, false);
     return;
   }
 
   if (!defer_start)
     InsertIntoResourceQueue(request, *info);
 }
 
 void ResourceDispatcherHost::InsertIntoResourceQueue(
-    URLRequest* request,
+    net::URLRequest* request,
     const ResourceDispatcherHostRequestInfo& request_info) {
   resource_queue_.AddRequest(request, request_info);
 
   // Make sure we have the load state monitor running
   if (!update_load_states_timer_.IsRunning()) {
     update_load_states_timer_.Start(
         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
         this, &ResourceDispatcherHost::UpdateLoadStates);
   }
 }
 
 bool ResourceDispatcherHost::PauseRequestIfNeeded(
     ResourceDispatcherHostRequestInfo* info) {
   if (info->pause_count() > 0)
     info->set_is_paused(true);
   return info->is_paused();
 }
 
 void ResourceDispatcherHost::ResumeRequest(const GlobalRequestID& request_id) {
   PendingRequestList::iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())  // The request may have been destroyed
     return;
 
-  URLRequest* request = i->second;
+  net::URLRequest* request = i->second;
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!info->is_paused())
     return;
 
   VLOG(1) << "Resuming: " << i->second->url().spec();
 
   info->set_is_paused(false);
 
   if (info->called_on_response_started()) {
     if (info->has_started_reading()) {
       OnReadCompleted(i->second, info->paused_read_bytes());
     } else {
       StartReading(request);
     }
   } else {
     OnResponseStarted(i->second);
   }
 }
 
-void ResourceDispatcherHost::StartReading(URLRequest* request) {
+void ResourceDispatcherHost::StartReading(net::URLRequest* request) {
   // Start reading.
   int bytes_read = 0;
   if (Read(request, &bytes_read)) {
     OnReadCompleted(request, bytes_read);
   } else if (!request->status().is_io_pending()) {
     DCHECK(!InfoForRequest(request)->is_paused());
     // If the error is not an IO pending, then we're done reading.
     OnResponseCompleted(request);
   }
 }
 
-bool ResourceDispatcherHost::Read(URLRequest* request, int* bytes_read) {
+bool ResourceDispatcherHost::Read(net::URLRequest* request, int* bytes_read) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   DCHECK(!info->is_paused());
 
   net::IOBuffer* buf;
   int buf_size;
   if (!info->resource_handler()->OnWillRead(info->request_id(),
                                             &buf, &buf_size, -1)) {
     return false;
   }
 
   DCHECK(buf);
   DCHECK(buf_size > 0);
 
   info->set_has_started_reading(true);
   return request->Read(buf, buf_size, bytes_read);
 }
 
-void ResourceDispatcherHost::OnReadCompleted(URLRequest* request,
+void ResourceDispatcherHost::OnReadCompleted(net::URLRequest* request,
                                              int bytes_read) {
   DCHECK(request);
   VLOG(1) << "OnReadCompleted: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   // OnReadCompleted can be called without Read (e.g., for chrome:// URLs).
   // Make sure we know that a read has begun.
   info->set_has_started_reading(true);
 
   if (PauseRequestIfNeeded(info)) {
@@ skipping 32 matching lines @@
             << request->url().spec();
     return;
   }
 
   // If the status is not IO pending then we've either finished (success) or we
   // had an error.  Either way, we're done!
   if (!request->status().is_io_pending())
     OnResponseCompleted(request);
 }
 
-bool ResourceDispatcherHost::CompleteRead(URLRequest* request,
+bool ResourceDispatcherHost::CompleteRead(net::URLRequest* request,
                                           int* bytes_read) {
   if (!request || !request->status().is_success()) {
     NOTREACHED();
     return false;
   }
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!info->resource_handler()->OnReadCompleted(info->request_id(),
                                                  bytes_read)) {
     CancelRequestInternal(request, false);
     return false;
   }
 
   return *bytes_read != 0;
 }
 
-void ResourceDispatcherHost::OnResponseCompleted(URLRequest* request) {
+void ResourceDispatcherHost::OnResponseCompleted(net::URLRequest* request) {
   VLOG(1) << "OnResponseCompleted: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   // If the load for a main frame has failed, track it in a histogram,
   // since it will probably cause the user to see an error page.
   if (!request->status().is_success() &&
       info->resource_type() == ResourceType::MAIN_FRAME) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.ErrorCodesForMainFrame",
                                      -request->status().os_error(),
                                      GetAllNetErrorCodes());
@@ skipping 16 matching lines @@
 
     // The request is complete so we can remove it.
     RemovePendingRequest(info->child_id(), info->request_id());
   }
   // If the handler's OnResponseCompleted returns false, we are deferring the
   // call until later.  We will notify the world and clean up when we resume.
 }
 
 // static
 ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
-    URLRequest* request) {
+    net::URLRequest* request) {
   // Avoid writing this function twice by casting the cosnt version.
-  const URLRequest* const_request = request;
+  const net::URLRequest* const_request = request;
   return const_cast<ResourceDispatcherHostRequestInfo*>(
       InfoForRequest(const_request));
 }
 
 // static
 const ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
-    const URLRequest* request) {
+    const net::URLRequest* request) {
   const ResourceDispatcherHostRequestInfo* info =
       static_cast<const ResourceDispatcherHostRequestInfo*>(
           request->GetUserData(NULL));
   DLOG_IF(WARNING, !info) << "Request doesn't seem to have our data";
   return info;
 }
 
 // static
-bool ResourceDispatcherHost::RenderViewForRequest(const URLRequest* request,
-                                                  int* render_process_host_id,
-                                                  int* render_view_host_id) {
+bool ResourceDispatcherHost::RenderViewForRequest(
+    const net::URLRequest* request,
+    int* render_process_host_id,
+    int* render_view_host_id) {
   const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!info) {
     *render_process_host_id = -1;
     *render_view_host_id = -1;
     return false;
   }
 
   // If the request is from the worker process, find a tab that owns the worker.
   if (info->process_type() == ChildProcessInfo::WORKER_PROCESS) {
     const WorkerProcessHost::WorkerInstance* worker_instance =
@@ skipping 18 matching lines @@
 }
 
 void ResourceDispatcherHost::AddObserver(Observer* obs) {
   observer_list_.AddObserver(obs);
 }
 
 void ResourceDispatcherHost::RemoveObserver(Observer* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
-URLRequest* ResourceDispatcherHost::GetURLRequest(
+net::URLRequest* ResourceDispatcherHost::GetURLRequest(
     const GlobalRequestID& request_id) const {
   // This should be running in the IO loop.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())
     return NULL;
 
   return i->second;
 }
 
-static int GetCertID(URLRequest* request, int child_id) {
+static int GetCertID(net::URLRequest* request, int child_id) {
   if (request->ssl_info().cert) {
     return CertStore::GetSharedInstance()->StoreCert(request->ssl_info().cert,
                                                      child_id);
   }
   // If there is no SSL info attached to this request, we must either be a non
   // secure request, or the request has been canceled or failed (before the SSL
   // info was populated), or the response is an error (we have seen 403, 404,
   // and 501) made up by the proxy.
   DCHECK(!request->url().SchemeIsSecure() ||
          (request->status().status() == URLRequestStatus::CANCELED) ||
          (request->status().status() == URLRequestStatus::FAILED) ||
          ((request->response_headers()->response_code() >= 400) &&
          (request->response_headers()->response_code() <= 599)));
   return 0;
 }
 
-void ResourceDispatcherHost::NotifyResponseStarted(URLRequest* request,
+void ResourceDispatcherHost::NotifyResponseStarted(net::URLRequest* request,
                                                    int child_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_, OnRequestStarted(this, request));
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   CallRenderViewHostResourceDelegate(
       render_process_id, render_view_id,
       &RenderViewHostDelegate::Resource::DidStartReceivingResourceResponse,
       ResourceRequestDetails(request, GetCertID(request, child_id)));
 }
 
-void ResourceDispatcherHost::NotifyResponseCompleted(URLRequest* request,
+void ResourceDispatcherHost::NotifyResponseCompleted(net::URLRequest* request,
                                                      int child_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnResponseCompleted(this, request));
 }
 
-void ResourceDispatcherHost::NotifyReceivedRedirect(URLRequest* request,
+void ResourceDispatcherHost::NotifyReceivedRedirect(net::URLRequest* request,
                                                     int child_id,
                                                     const GURL& new_url) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnReceivedRedirect(this, request, new_url));
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
@@ skipping 61 matching lines @@
   // Populate this map with load state changes, and then send them on to the UI
   // thread where they can be passed along to the respective RVHs.
   LoadInfoMap info_map;
 
   PendingRequestList::const_iterator i;
 
   // Determine the largest upload size of all requests
   // in each View (good chance it's zero).
   std::map<std::pair<int, int>, uint64> largest_upload_size;
   for (i = pending_requests_.begin(); i != pending_requests_.end(); ++i) {
-    URLRequest* request = i->second;
+    net::URLRequest* request = i->second;
     ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
     uint64 upload_size = info->upload_size();
     if (request->GetLoadState() != net::LOAD_STATE_SENDING_REQUEST)
       upload_size = 0;
     std::pair<int, int> key(info->child_id(), info->route_id());
     if (upload_size && largest_upload_size[key] < upload_size)
       largest_upload_size[key] = upload_size;
   }
 
   for (i = pending_requests_.begin(); i != pending_requests_.end(); ++i) {
-    URLRequest* request = i->second;
+    net::URLRequest* request = i->second;
     net::LoadState load_state = request->GetLoadState();
     ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
     // We also poll for upload progress on this timer and send upload
     // progress ipc messages to the plugin process.
     bool update_upload_progress = MaybeUpdateUploadProgress(info, request);
 
     if (info->last_load_state() != load_state || update_upload_progress) {
       std::pair<int, int> key(info->child_id(), info->route_id());
 
@@ skipping 28 matching lines @@
 
   LoadInfoUpdateTask* task = new LoadInfoUpdateTask;
   task->info_map.swap(info_map);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, task);
 }
 
 // Calls the ResourceHandler to send upload progress messages to the renderer.
 // Returns true iff an upload progress message should be sent to the UI thread.
 bool ResourceDispatcherHost::MaybeUpdateUploadProgress(
     ResourceDispatcherHostRequestInfo *info,
-    URLRequest *request) {
+    net::URLRequest *request) {
 
   if (!info->upload_size() || info->waiting_for_upload_progress_ack())
     return false;
 
   uint64 size = info->upload_size();
   uint64 position = request->GetUploadProgress();
   if (position == info->last_upload_position())
     return false;  // no progress made since last time
 
   const uint64 kHalfPercentIncrements = 200;
@@ skipping 50 matching lines @@
 
   BlockedRequestsList* requests = iter->second;
 
   // Removing the vector from the map unblocks any subsequent requests.
   blocked_requests_map_.erase(iter);
 
   for (BlockedRequestsList::iterator req_iter = requests->begin();
        req_iter != requests->end(); ++req_iter) {
     // Remove the memory credit that we added when pushing the request onto
     // the blocked list.
-    URLRequest* request = *req_iter;
+    net::URLRequest* request = *req_iter;
     ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
     IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                            info->child_id());
     if (cancel_requests)
       delete request;
     else
       BeginRequestInternal(request);
   }
 
   delete requests;
 }
 
-bool ResourceDispatcherHost::IsValidRequest(URLRequest* request) {
+bool ResourceDispatcherHost::IsValidRequest(net::URLRequest* request) {
   if (!request)
     return false;
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   return pending_requests_.find(
       GlobalRequestID(info->child_id(), info->request_id())) !=
       pending_requests_.end();
 }
 
 // static
 bool ResourceDispatcherHost::IsResourceDispatcherHostMessage(
@@ skipping 87 matching lines @@
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;