Add a ResourceScheduler to ResourceDispatcherHost.

content/browser/loader/resource_scheduler_unittest.cc

Index: content/browser/loader/resource_scheduler_unittest.cc
diff --git a/content/browser/loader/resource_scheduler_unittest.cc b/content/browser/loader/resource_scheduler_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b973e980ecb4bae2805ec479db919680d85e24b4
--- /dev/null
+++ b/content/browser/loader/resource_scheduler_unittest.cc
@@ -0,0 +1,131 @@
+// 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/message_loop.h"
+#include "content/browser/loader/resource_handler.h"
+#include "content/browser/loader/resource_loader.h"
+#include "content/browser/loader/resource_loader_delegate.h"
+#include "content/browser/loader/resource_request_info_impl.h"
+#include "content/public/browser/global_request_id.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+namespace {
+
+class TestRequestFactory;
+
+const int kChildId = 30;
+const int kRouteId = 75;
+
+class TestRequest : public ResourceScheduler::Loadable {
+ public:
+  TestRequest(scoped_ptr<net::URLRequest> url_request)
+      : started_(false),
+        url_request_(url_request.Pass()) {}
+
+  bool started() const { return started_; }
+
+ private:
+  virtual void StartRequest() OVERRIDE { started_ = true; }
+  virtual net::URLRequest* url_request() OVERRIDE { return url_request_.get(); }
+
+  bool started_;
+  scoped_ptr<net::URLRequest> url_request_;
+};
+
+class ResourceSchedulerTest : public testing::Test {
+ protected:
+  ResourceSchedulerTest()
+      : message_loop_(MessageLoop::TYPE_IO) {
+    scheduler_.OnCreate(kChildId, kRouteId);
+  }
+
+  virtual ~ResourceSchedulerTest() {
+    scheduler_.OnDestroy(kChildId, kRouteId);
+  }
+
+  TestRequest* NewRequest(const char* url, net::RequestPriority priority) {
+    scoped_ptr<net::URLRequest> url_request(
+        context_.CreateRequest(GURL(url), NULL));
+    url_request->set_priority(priority);
+    return new TestRequest(url_request.Pass());
+  }
+
+  MessageLoop message_loop_;
+  ResourceScheduler scheduler_;
+  net::TestURLRequestContext context_;
+};
+
+TEST_F(ResourceSchedulerTest, OneIsolatedLowRequest) {
+  scoped_ptr<TestRequest> request(NewRequest("http://host/1", net::LOW));
+  scoped_ptr<ResourceScheduler::LoadHandle> handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, request.get()));
+  EXPECT_TRUE(request->started());
+}
+
+TEST_F(ResourceSchedulerTest, LowBlocksUntilIdle) {
+  scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
+  scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOW));
+  scoped_ptr<ResourceScheduler::LoadHandle> high_handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, high.get()));
+  scoped_ptr<ResourceScheduler::LoadHandle> low_handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, low.get()));
+  EXPECT_TRUE(high->started());
+  EXPECT_FALSE(low->started());
+  high_handle.reset();
+  EXPECT_TRUE(low->started());
+}
+
+TEST_F(ResourceSchedulerTest, LowBlocksUntilPaint) {
+  scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
+  scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOW));
+  scoped_ptr<ResourceScheduler::LoadHandle> high_handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, high.get()));
+  scoped_ptr<ResourceScheduler::LoadHandle> low_handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, low.get()));
+  EXPECT_TRUE(high->started());
+  EXPECT_FALSE(low->started());
+  scheduler_.OnPaint(kChildId, kRouteId);
+  EXPECT_TRUE(low->started());
+}
+
+TEST_F(ResourceSchedulerTest, NavigationResetsPaintState) {
+  scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
+  scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOW));
+  scheduler_.OnPaint(kChildId, kRouteId);
+  scheduler_.OnNavigate(kChildId, kRouteId);
+  scoped_ptr<ResourceScheduler::LoadHandle> high_handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, high.get()));
+  scoped_ptr<ResourceScheduler::LoadHandle> low_handle(scheduler_.ScheduleLoad(
+      kChildId, kRouteId, low.get()));
+  EXPECT_TRUE(high->started());
+  EXPECT_FALSE(low->started());
+}
+
+TEST_F(ResourceSchedulerTest, BackgroundRequestStartsImmediately) {
+  const int route_id = 0;  // Indicates a background request.
+  scoped_ptr<TestRequest> request(NewRequest("http://host/1", net::LOW));
+  scoped_ptr<ResourceScheduler::LoadHandle> handle(scheduler_.ScheduleLoad(
+      kChildId, route_id, request.get()));
+  EXPECT_TRUE(request->started());
+}
+
+TEST_F(ResourceSchedulerTest, DestroyTabBeforeCancelingLoad) {
+  const int new_route_id = kRouteId +1;
+  scheduler_.OnCreate(kChildId, new_route_id);
+  scoped_ptr<TestRequest> request(NewRequest("http://host/1", net::LOW));
+  scoped_ptr<ResourceScheduler::LoadHandle> handle(scheduler_.ScheduleLoad(
+      kChildId, new_route_id, request.get()));
+  scheduler_.OnDestroy(kChildId, new_route_id);
+  // Note that new_route_id is destroyed before handle goes out of scope.
+}
+
+}  // unnamed namespace
+
+}  // namespace content