Add a ResourceScheduler to ResourceDispatcherHost.

content/browser/renderer_host/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/renderer_host/resource_scheduler.h"
+
+#include "base/stl_util.h"
+#include "content/browser/renderer_host/resource_loader.h"
+#include "net/base/request_priority.h"
+#include "net/url_request/url_request.h"
+
+namespace content {
+
+namespace {
+
+ResourceScheduler::ClientId MakeClientId(int child_id, int route_id) {
+  return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
+}
+
+ResourceScheduler::BackgroundRequestId MakeBackgroundRequestId(int child_id,
+                                                               int request_id) {
+  return (static_cast<ResourceScheduler::ClientId>(child_id) << 32)
+      | request_id;
+}
+
+}  // unnamed namespace
+
+// Tracks a background request issued by a tab. <a ping> is an example.
+// Currently, these are loaded immediately, with no scheduling.
+class ResourceScheduler::BackgroundLoadHandle : public LoadHandle {
+ public:
+  BackgroundLoadHandle(BackgroundRequestId request_id,
+                       const linked_ptr<ResourceLoader>& loader,
+                       ResourceScheduler* scheduler)
+      : request_id_(request_id),
+        loader_(loader),
+        scheduler_(scheduler) {
+  }
+
+  virtual ~BackgroundLoadHandle() {
+    scheduler_->RemoveBackgroundLoad(request_id_);
+  }
+
+  virtual linked_ptr<ResourceLoader> loader() OVERRIDE { return loader_; }
+
+  BackgroundRequestId request_id_;

[willchan no longer on Chromium, 2012/12/03 02:30:16]

private:

+  linked_ptr<ResourceLoader> loader_;
+  ResourceScheduler* scheduler_;
+};
+
+// Represents a normal resource load.
+class ResourceScheduler::ScheduledLoadHandle : public LoadHandle {
+ public:
+  ScheduledLoadHandle(ClientId client_id,
+                      int request_id,
+                      const linked_ptr<ResourceLoader>& loader,
+                      ResourceScheduler* scheduler)
+      : client_id_(client_id),
+        request_id_(request_id),
+        loader_(loader),
+        scheduler_(scheduler) {
+  }
+
+  virtual ~ScheduledLoadHandle() {
+    scheduler_->RemoveLoad(client_id_, request_id_);
+  }
+
+  virtual linked_ptr<ResourceLoader> loader() OVERRIDE { return loader_; }
+
+ private:
+  ClientId client_id_;
+  int request_id_;
+  linked_ptr<ResourceLoader> loader_;
+  ResourceScheduler* scheduler_;
+};
+
+ResourceScheduler::ResourceScheduler() {
+}
+
+ResourceScheduler::~ResourceScheduler() {
+}
+
+scoped_ptr<ResourceScheduler::LoadHandle> ResourceScheduler::ScheduleLoad(
+    int child_id,
+    int route_id,
+    int request_id,
+    const linked_ptr<ResourceLoader>& loader) {
+  if (route_id == 0) {
+    // <a ping> requests don't have a route_id.
+    BackgroundRequestId background_id = MakeBackgroundRequestId(child_id,
+                                                                request_id);
+    background_requests_.insert(background_id);
+    loader->StartRequest();

[willchan no longer on Chromium, 2012/12/03 02:30:16]

I'm not sure if all URLRequestJobs complete asynchronously. If not, then this
may synchronously call back into ResourceDispatcherHostImpl and delete the
loader. I need to read through the code to make sure everything's safe.

[James Simonsen, 2012/12/05 01:52:45]

No longer an issue. We don't hang on to it any more.

+    scoped_ptr<LoadHandle> handle(new BackgroundLoadHandle(
+        background_id, loader, this));
+    return handle.Pass();
+  }
+
+  ClientId client_id = MakeClientId(child_id, route_id);
+  CHECK(ContainsKey(client_map_, client_id));
+  Client* client = client_map_[client_id];
+  DCHECK(!client->closed);
+  scoped_ptr<LoadHandle> handle(new ScheduledLoadHandle(
+      client_id, request_id, loader, this));
+  Request request = { request_id, loader.get() };
+
+  if (loader->request()->priority() < net::MEDIUM &&
+      !client->in_flight_requests.empty() && !client->has_painted) {
+    client->pending_requests.push_back(request);
+    return handle.Pass();
+  }
+
+  StartRequest(request, client);
+  return handle.Pass();
+}
+
+void ResourceScheduler::RemoveLoad(ClientId client_id, int request_id) {
+  DCHECK(ContainsKey(client_map_, client_id));
+  Client* client = client_map_[client_id];
+  RequestIdSet::iterator it = client->in_flight_requests.find(request_id);
+  if (it == client->in_flight_requests.end()) {
+    bool removed = false;
+    RequestQueue::iterator queue_it;
+    for (queue_it = client->pending_requests.begin();
+         queue_it != client->pending_requests.end(); ++queue_it) {
+      if (queue_it->request_id == request_id) {
+        client->pending_requests.erase(queue_it);
+        removed = true;
+        break;
+      }
+    }
+    DCHECK(removed);
+    DCHECK(!ContainsKey(client->in_flight_requests, request_id));
+  } else {
+    bool erased = client->in_flight_requests.erase(request_id);
+    DCHECK(erased);
+  }
+
+  if (client->closed) {
+    if (client->in_flight_requests.empty()
+        && client->pending_requests.empty()) {
+      delete client;
+      client_map_.erase(client_id);
+    }
+  } else if (client->in_flight_requests.empty()) {
+    LoadPendingRequests(client);
+  }
+}
+
+void ResourceScheduler::RemoveBackgroundLoad(BackgroundRequestId request_id) {
+  bool erased = background_requests_.erase(request_id);
+  DCHECK(erased);
+}
+
+void ResourceScheduler::OnCreate(int child_id, int route_id) {
+  ClientId client_id = MakeClientId(child_id, route_id);
+  DCHECK(!ContainsKey(client_map_, client_id));
+  client_map_[client_id] = new Client;
+}
+
+void ResourceScheduler::OnNavigate(int child_id, int route_id) {
+  ClientId client_id = MakeClientId(child_id, route_id);
+  DCHECK(ContainsKey(client_map_, client_id));
+  Client* client = client_map_[client_id];
+  client->has_painted = false;
+}
+
+void ResourceScheduler::OnPaint(int child_id, int route_id) {
+  ClientId client_id = MakeClientId(child_id, route_id);
+  DCHECK(ContainsKey(client_map_, client_id));
+  Client* client = client_map_[client_id];
+  if (!client->has_painted) {
+    client->has_painted = true;
+    LoadPendingRequests(client);
+  }
+}
+
+void ResourceScheduler::OnDestroy(int child_id, int route_id) {
+  ClientId client_id = MakeClientId(child_id, route_id);
+  DCHECK(ContainsKey(client_map_, client_id));
+  Client* client = client_map_[client_id];
+  if (client->pending_requests.empty() && client->in_flight_requests.empty()) {
+    delete client;
+    client_map_.erase(client_id);
+  } else {
+    client->closed = true;
+  }
+}
+
+void ResourceScheduler::StartRequest(Request request, Client* client) {
+  client->in_flight_requests.insert(request.request_id);
+  request.loader->StartRequest();
+}
+
+void ResourceScheduler::LoadPendingRequests(Client* client) {
+  RequestQueue::iterator it;
+  for (it = client->pending_requests.begin();
+       it != client->pending_requests.end(); ++it) {
+    StartRequest(*it, client);
+  }
+  client->pending_requests.clear();
+}
+
+ResourceScheduler::Client::Client()
+    : has_painted(false),
+      closed(false) {
+}
+
+}  // namespace content