ResourceScheduler should use renderer notifications instead of MRUCache to track renderers.

content/browser/loader/resource_scheduler.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.
 
 #include "content/browser/loader/resource_scheduler.h"
 
 #include "base/stl_util.h"
 #include "content/common/resource_messages.h"
 #include "content/browser/loader/resource_message_delegate.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_throttle.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request.h"
 
 namespace content {
 
-// TODO(simonjam): This is arbitrary. Experiment.
-static const int kMaxNumNavigationsToTrack = 5;
-
 class ResourceScheduler::ScheduledResourceRequest
     : public ResourceMessageDelegate,
       public ResourceThrottle {
  public:
   ScheduledResourceRequest(const ClientId& client_id,
                            net::URLRequest* request,
                            ResourceScheduler* scheduler)
       : ResourceMessageDelegate(request),
         client_id_(client_id),
         request_(request),
@@ skipping 44 matching lines @@
 
   ClientId client_id_;
   net::URLRequest* request_;
   bool ready_;
   bool deferred_;
   ResourceScheduler* scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScheduledResourceRequest);
 };
 
-ResourceScheduler::ResourceScheduler()
-    : client_map_(kMaxNumNavigationsToTrack) {
+ResourceScheduler::ResourceScheduler() {
 }
 
 ResourceScheduler::~ResourceScheduler() {
   for (ClientMap::iterator it ALLOW_UNUSED = client_map_.begin();
        it != client_map_.end(); ++it) {
     DCHECK(it->second->pending_requests.empty());
     DCHECK(it->second->in_flight_requests.empty());
   }
   DCHECK(unowned_requests_.empty());
+  DCHECK(client_map_.empty());
 }
 
 scoped_ptr<ResourceThrottle> ResourceScheduler::ScheduleRequest(
     int child_id,
     int route_id,
     net::URLRequest* url_request) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
   scoped_ptr<ScheduledResourceRequest> request(
       new ScheduledResourceRequest(client_id, url_request, this));
 
-  ClientMap::iterator it = client_map_.Get(client_id);
+  ClientMap::iterator it = client_map_.find(client_id);
   if (it == client_map_.end()) {
     // There are several ways this could happen:
     // 1. <a ping> requests don't have a route_id.
     // 2. Most unittests don't send the IPCs needed to register Clients.
     // 3. The tab is closed while a RequestResource IPC is in flight.
-    // 4. The tab hasn't navigated recently.
     unowned_requests_.insert(request.get());
     request->Start();
     return request.PassAs<ResourceThrottle>();
   }
 
   Client* client = it->second;
 
   bool is_synchronous = (url_request->load_flags() & net::LOAD_IGNORE_LIMITS) ==
       net::LOAD_IGNORE_LIMITS;
   bool is_low_priority =
       url_request->priority() < net::LOW && !is_synchronous;
 
   if (is_low_priority && !client->in_flight_requests.empty() &&
       !client->has_body) {
     client->pending_requests.push_back(request.get());
   } else {
     StartRequest(request.get(), client);
   }
   return request.PassAs<ResourceThrottle>();
 }
 
 void ResourceScheduler::RemoveRequest(ScheduledResourceRequest* request) {
   DCHECK(CalledOnValidThread());
   if (ContainsKey(unowned_requests_, request)) {
     unowned_requests_.erase(request);
     return;
   }
 
-  ClientMap::iterator client_it = client_map_.Get(request->client_id());
+  ClientMap::iterator client_it = client_map_.find(request->client_id());
   if (client_it == client_map_.end()) {
     return;
   }
 
   Client* client = client_it->second;
   RequestSet::iterator request_it = client->in_flight_requests.find(request);
   if (request_it == client->in_flight_requests.end()) {
     bool removed = false;
     RequestQueue::iterator queue_it;
     for (queue_it = client->pending_requests.begin();
@@ skipping 11 matching lines @@
     DCHECK(erased);
   }
 
   if (client->in_flight_requests.empty()) {
     // Since the network is now idle, we may as well load some of the low
     // priority requests.
     LoadPendingRequests(client);
   }
 }
 
+void ResourceScheduler::OnClientCreated(int child_id, int route_id) {
+  DCHECK(CalledOnValidThread());
+  ClientId client_id = MakeClientId(child_id, route_id);
+  DCHECK(!ContainsKey(client_map_, client_id));
+
+  client_map_[client_id] = new Client;
+}
+
+void ResourceScheduler::OnClientDeleted(int child_id, int route_id) {
+  DCHECK(CalledOnValidThread());
+  ClientId client_id = MakeClientId(child_id, route_id);
+  DCHECK(ContainsKey(client_map_, client_id));
+  ClientMap::iterator it = client_map_.find(client_id);
+  Client* client = it->second;
+
+  // FYI, ResourceDispatcherHost cancels all of the requests after this function
+  // is called. It should end up canceling all of the requests except for a
+  // cross-renderer navigation.
+  for (RequestSet::iterator it = client->in_flight_requests.begin();
+       it != client->in_flight_requests.end(); ++it) {
+    unowned_requests_.insert(*it);
+  }
+  client->in_flight_requests.clear();
+
+  delete client;
+  client_map_.erase(it);
+}
+
 void ResourceScheduler::OnNavigate(int child_id, int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
 
-  ClientMap::iterator it = client_map_.Get(client_id);
+  ClientMap::iterator it = client_map_.find(client_id);
   if (it == client_map_.end()) {
-    it = client_map_.Put(client_id, new Client(this));
+    // The client was likely deleted shortly before we received this IPC.
+    return;
   }
 
   Client* client = it->second;
   client->has_body = false;
 }
 
 void ResourceScheduler::OnWillInsertBody(int child_id, int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
-  ClientMap::iterator it = client_map_.Get(client_id);
+
+  ClientMap::iterator it = client_map_.find(client_id);
   if (it == client_map_.end()) {
+    // The client was likely deleted shortly before we received this IPC.
     return;
   }
 
   Client* client = it->second;
+  client->has_body = false;
   if (!client->has_body) {
     client->has_body = true;
     LoadPendingRequests(client);
   }
 }
 
 void ResourceScheduler::StartRequest(ScheduledResourceRequest* request,
                                      Client* client) {
   client->in_flight_requests.insert(request);
   request->Start();
 }
 
 void ResourceScheduler::LoadPendingRequests(Client* client) {
   while (!client->pending_requests.empty()) {
     ScheduledResourceRequest* request = client->pending_requests.front();
     client->pending_requests.erase(client->pending_requests.begin());
     StartRequest(request, client);
   }
 }
 
-void ResourceScheduler::RemoveClient(Client* client) {
-  LoadPendingRequests(client);
-  for (RequestSet::iterator it = client->in_flight_requests.begin();
-       it != client->in_flight_requests.end(); ++it) {
-    unowned_requests_.insert(*it);
-  }
-  client->in_flight_requests.clear();
-}
-
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
-ResourceScheduler::Client::Client(ResourceScheduler* scheduler)
-    : has_body(false),
-      scheduler_(scheduler) {
+ResourceScheduler::Client::Client()
+    : has_body(false) {
 }
 
 ResourceScheduler::Client::~Client() {
-  scheduler_->RemoveClient(this);
-  DCHECK(in_flight_requests.empty());
-  DCHECK(pending_requests.empty());
 }
 
 }  // namespace content