Headless: make URLRequestDispatcher aware of navigations

headless/public/util/deterministic_dispatcher_test.cc

Index: headless/public/util/deterministic_dispatcher_test.cc
diff --git a/headless/public/util/deterministic_dispatcher_test.cc b/headless/public/util/deterministic_dispatcher_test.cc
index 24cede8b2e9a9df3bf368a6d6e03513c4ef4139a..7c2c60494bd8830613b0fa43e2fad1dec0c6585b 100644
--- a/headless/public/util/deterministic_dispatcher_test.cc
+++ b/headless/public/util/deterministic_dispatcher_test.cc
@@ -8,8 +8,10 @@
 #include <string>
 #include <vector>
 
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "headless/public/util/navigation_request.h"
 #include "headless/public/util/testing/fake_managed_dispatch_url_request_job.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -126,4 +128,70 @@ TEST_F(DeterministicDispatcherTest, JobKilled) {
   EXPECT_TRUE(notifications.empty());
 }
 
+namespace {
+class NavigationRequestForTest : public NavigationRequest {
+ public:
+  explicit NavigationRequestForTest(base::Closure* done_closure)
+      : done_closure_(done_closure) {}
+
+  ~NavigationRequestForTest() override {}
+
+  // NavigationRequest implementation:
+  void StartProcessing(base::Closure done_callback) override {
+    *done_closure_ = std::move(done_callback);
+  }
+
+ private:
+  base::Closure* done_closure_;  // NOT OWNED
+};
+}  // namespace
+
+TEST_F(DeterministicDispatcherTest, NavigationBlocksUrlRequests) {
+  std::vector<std::string> notifications;
+  std::unique_ptr<FakeManagedDispatchURLRequestJob> job1(
+      new FakeManagedDispatchURLRequestJob(deterministic_dispatcher_.get(), 1,
+                                           &notifications));
+  base::Closure navigation_done_closure;
+  deterministic_dispatcher_->NavigationRequested(
+      base::MakeUnique<NavigationRequestForTest>(&navigation_done_closure));
+  std::unique_ptr<FakeManagedDispatchURLRequestJob> job2(
+      new FakeManagedDispatchURLRequestJob(deterministic_dispatcher_.get(), 2,
+                                           &notifications));
+  std::unique_ptr<FakeManagedDispatchURLRequestJob> job3(
+      new FakeManagedDispatchURLRequestJob(deterministic_dispatcher_.get(), 3,
+                                           &notifications));
+  std::unique_ptr<FakeManagedDispatchURLRequestJob> job4(
+      new FakeManagedDispatchURLRequestJob(deterministic_dispatcher_.get(), 4,
+                                           &notifications));
+  job1->DispatchHeadersComplete();
+  job2->DispatchHeadersComplete();
+  job3->DispatchHeadersComplete();
+  job4->DispatchHeadersComplete();
+
+  EXPECT_TRUE(notifications.empty());
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(notifications, ElementsAre("id: 1 OK"));
+
+  // This triggers a call to NavigationRequestForTest::StartProcessing.
+  job1.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(notifications, ElementsAre("id: 1 OK"));
+
+  // Navigations should be blocked until we call the done closure.
+  navigation_done_closure.Run();
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(notifications, ElementsAre("id: 1 OK", "id: 2 OK"));
+
+  job2.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(notifications, ElementsAre("id: 1 OK", "id: 2 OK", "id: 3 OK"));
+
+  job3.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(notifications,
+              ElementsAre("id: 1 OK", "id: 2 OK", "id: 3 OK", "id: 4 OK"));
+}
+
 }  // namespace headless