Revert 183382

content/browser/loader/resource_dispatcher_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
@@ skipping 187 matching lines @@
 #if defined(OS_WIN)
 #pragma warning(disable: 4748)
 #pragma optimize("", off)
 #endif
 
 #if defined(OS_WIN)
 #pragma optimize("", on)
 #pragma warning(default: 4748)
 #endif
 
+net::RequestPriority DetermineRequestPriority(
+    const ResourceHostMsg_Request& request_data) {
+  switch (request_data.priority) {
+    case WebKit::WebURLRequest::PriorityVeryHigh:
+      return net::HIGHEST;
+
+    case WebKit::WebURLRequest::PriorityHigh:
+      return net::MEDIUM;
+
+    case WebKit::WebURLRequest::PriorityMedium:
+      return net::LOW;
+
+    case WebKit::WebURLRequest::PriorityLow:
+      return net::LOWEST;
+
+    case WebKit::WebURLRequest::PriorityVeryLow:
+      return net::IDLE;
+
+    case WebKit::WebURLRequest::PriorityUnresolved:
+    default:
+      NOTREACHED();
+      return net::LOW;
+  }
+}
+
 void OnSwapOutACKHelper(int render_process_id,
                         int render_view_id,
                         bool timed_out) {
   RenderViewHostImpl* rvh = RenderViewHostImpl::FromID(render_process_id,
                                                        render_view_id);
   if (rvh)
     rvh->OnSwapOutACK(timed_out);
 }
 
 net::Error CallbackAndReturn(
@@ skipping 89 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   GetContentClient()->browser()->ResourceDispatcherHostCreated();
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&ResourceDispatcherHostImpl::OnInit,
-                                     base::Unretained(this)));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&appcache::AppCacheInterceptor::EnsureRegistered));
 
   update_load_states_timer_.reset(
       new base::RepeatingTimer<ResourceDispatcherHostImpl>());
 }
 
 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
   DCHECK(g_resource_dispatcher_host);
   g_resource_dispatcher_host = NULL;
 }
 
@@ skipping 388 matching lines @@
       ResourceRequestInfoImpl::ForRequest(request);
   if (!info) {
     *render_process_id = -1;
     *render_view_id = -1;
     return false;
   }
 
   return info->GetAssociatedRenderView(render_process_id, render_view_id);
 }
 
-void ResourceDispatcherHostImpl::OnInit() {
-  scheduler_.reset(new ResourceScheduler);
-  appcache::AppCacheInterceptor::EnsureRegistered();
-}
-
 void ResourceDispatcherHostImpl::OnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   is_shutdown_ = true;
   pending_loaders_.clear();
 
   // Make sure we shutdown the timer now, otherwise by the time our destructor
   // runs if the timer is still running the Task is deleted twice (once by
   // the MessageLoop and the second time by RepeatingTimer).
   update_load_states_timer_.reset();
 
   // Clear blocked requests if any left.
   // Note that we have to do this in 2 passes as we cannot call
   // CancelBlockedRequestsForRoute while iterating over
   // blocked_loaders_map_, as it modifies it.
   std::set<ProcessRouteIDs> ids;
   for (BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.begin();
        iter != blocked_loaders_map_.end(); ++iter) {
     std::pair<std::set<ProcessRouteIDs>::iterator, bool> result =
         ids.insert(iter->first);
     // We should not have duplicates.
     DCHECK(result.second);
   }
   for (std::set<ProcessRouteIDs>::const_iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
     CancelBlockedRequestsForRoute(iter->first, iter->second);
   }
-
-  scheduler_.reset();
 }
 
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
     ResourceMessageFilter* filter,
     bool* message_was_ok) {
   filter_ = filter;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(ResourceDispatcherHostImpl, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
@@ skipping 142 matching lines @@
                                                       referrer.policy);
     net::HttpRequestHeaders headers;
     headers.AddHeadersFromString(request_data.headers);
     request->SetExtraRequestHeaders(headers);
   }
 
   // TODO(darin): Do we really need all of these URLRequest setters in the
   // transferred navigation case?
 
   request->set_load_flags(load_flags);
-  request->set_priority(request_data.priority);
+
+  request->set_priority(DetermineRequestPriority(request_data));
 
   // Resolve elements from request_body and prepare upload data.
   if (request_data.request_body) {
     request->set_upload(make_scoped_ptr(
         request_data.request_body->ResolveElementsAndCreateUploadDataStream(
             filter_->blob_storage_context()->controller(),
             filter_->file_system_context(),
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE))));
   }
 
@@ skipping 88 matching lines @@
     // Block power save while uploading data.
     throttles.push_back(new PowerSaveBlockResourceThrottle());
   }
 
   if (request_data.resource_type == ResourceType::MAIN_FRAME) {
     throttles.insert(
         throttles.begin(),
         new TransferNavigationResourceThrottle(request));
   }
 
-  throttles.push_back(
-      scheduler_->ScheduleRequest(child_id, route_id, request).release());
-
-  handler.reset(
-      new ThrottlingResourceHandler(handler.Pass(), child_id, request_id,
-                                    throttles.Pass()));
+  if (!throttles.empty()) {
+    handler.reset(
+        new ThrottlingResourceHandler(handler.Pass(), child_id, request_id,
+                                      throttles.Pass()));
+  }
 
   if (deferred_loader.get()) {
     pending_loaders_[extra_info->GetGlobalRequestID()] = deferred_loader;
     deferred_loader->CompleteTransfer(handler.Pass());
   } else {
     BeginRequestInternal(new_request.Pass(), handler.Pass());
   }
 }
 
 void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(int request_id) {
@@ skipping 647 matching lines @@
   DelegateMap::iterator it = delegate_map_.find(id);
   DCHECK(it->second->HasObserver(delegate));
   it->second->RemoveObserver(delegate);
   if (it->second->size() == 0) {
     delete it->second;
     delegate_map_.erase(it);
   }
 }
 
 }  // namespace content