Create an interface for explicit notification of Dispatcher about

net/tools/quic/quic_dispatcher_test.cc

Index: net/tools/quic/quic_dispatcher_test.cc
diff --git a/net/tools/quic/quic_dispatcher_test.cc b/net/tools/quic/quic_dispatcher_test.cc
index 27741b1012dd05c2ab090fd3659666ec6b907b21..4666fe64452ebe3ea3b4e67d1960f50e22b30eda 100644
--- a/net/tools/quic/quic_dispatcher_test.cc
+++ b/net/tools/quic/quic_dispatcher_test.cc
@@ -202,8 +202,9 @@ TEST_F(QuicDispatcherTest, Shutdown) {
 class MockTimeWaitListManager : public QuicTimeWaitListManager {
  public:
   MockTimeWaitListManager(QuicPacketWriter* writer,
+                          QuicServerSessionVisitor* visitor,
                           EpollServer* eps)
-      : QuicTimeWaitListManager(writer, eps, QuicSupportedVersions()) {
+      : QuicTimeWaitListManager(writer, visitor, eps, QuicSupportedVersions()) {
   }
 
   MOCK_METHOD4(ProcessPacket, void(const IPEndPoint& server_address,
@@ -215,7 +216,7 @@ class MockTimeWaitListManager : public QuicTimeWaitListManager {
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
-          QuicDispatcherPeer::GetWriter(&dispatcher_), &eps_);
+          QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
@@ -257,7 +258,7 @@ TEST_F(QuicDispatcherTest, TimeWaitListManager) {
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
-          QuicDispatcherPeer::GetWriter(&dispatcher_), &eps_);
+          QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
@@ -324,7 +325,7 @@ class QuicWriteBlockedListTest : public QuicDispatcherTest {
   }
 
   bool SetBlocked() {
-    writer_->write_blocked_ = true;;
+    writer_->write_blocked_ = true;
     return true;
   }
 
@@ -337,8 +338,9 @@ TEST_F(QuicWriteBlockedListTest, BasicOnCanWrite) {
   // No OnCanWrite calls because no connections are blocked.
   dispatcher_.OnCanWrite();
 
-  // Register connection 1 for events, and make sure it's nofitied.
-  blocked_list_->insert(make_pair(connection1(), true));
+  // Register connection 1 for events, and make sure it's notified.
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
   EXPECT_CALL(*connection1(), OnCanWrite());
   dispatcher_.OnCanWrite();
 
@@ -350,15 +352,17 @@ TEST_F(QuicWriteBlockedListTest, BasicOnCanWrite) {
 TEST_F(QuicWriteBlockedListTest, OnCanWriteOrder) {
   // Make sure we handle events in order.
   InSequence s;
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection2(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection2());
   EXPECT_CALL(*connection1(), OnCanWrite());
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
 
   // Check the other ordering.
-  blocked_list_->insert(make_pair(connection2(), true));
-  blocked_list_->insert(make_pair(connection1(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection2());
+  dispatcher_.OnWriteBlocked(connection1());
   EXPECT_CALL(*connection2(), OnCanWrite());
   EXPECT_CALL(*connection1(), OnCanWrite());
   dispatcher_.OnCanWrite();
@@ -366,37 +370,42 @@ TEST_F(QuicWriteBlockedListTest, OnCanWriteOrder) {
 
 TEST_F(QuicWriteBlockedListTest, OnCanWriteRemove) {
   // Add and remove one connction.
-  blocked_list_->insert(make_pair(connection1(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
   blocked_list_->erase(connection1());
   EXPECT_CALL(*connection1(), OnCanWrite()).Times(0);
   dispatcher_.OnCanWrite();
 
   // Add and remove one connction and make sure it doesn't affect others.
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection2(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection2());
   blocked_list_->erase(connection1());
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
 
   // Add it, remove it, and add it back and make sure things are OK.
-  blocked_list_->insert(make_pair(connection1(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
   blocked_list_->erase(connection1());
-  blocked_list_->insert(make_pair(connection1(), true));
+  dispatcher_.OnWriteBlocked(connection1());
   EXPECT_CALL(*connection1(), OnCanWrite()).Times(1);
   dispatcher_.OnCanWrite();
 }
 
 TEST_F(QuicWriteBlockedListTest, DoubleAdd) {
   // Make sure a double add does not necessitate a double remove.
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection1(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection1());
   blocked_list_->erase(connection1());
   EXPECT_CALL(*connection1(), OnCanWrite()).Times(0);
   dispatcher_.OnCanWrite();
 
   // Make sure a double add does not result in two OnCanWrite calls.
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection1(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection1());
   EXPECT_CALL(*connection1(), OnCanWrite()).Times(1);
   dispatcher_.OnCanWrite();
 }
@@ -404,8 +413,9 @@ TEST_F(QuicWriteBlockedListTest, DoubleAdd) {
 TEST_F(QuicWriteBlockedListTest, OnCanWriteHandleBlock) {
   // Finally make sure if we write block on a write call, we stop calling.
   InSequence s;
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection2(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection2());
   EXPECT_CALL(*connection1(), OnCanWrite()).WillOnce(
       Invoke(this, &QuicWriteBlockedListTest::SetBlocked));
   EXPECT_CALL(*connection2(), OnCanWrite()).Times(0);
@@ -420,8 +430,9 @@ TEST_F(QuicWriteBlockedListTest, LimitedWrites) {
   // Make sure we call both writers.  The first will register for more writing
   // but should not be immediately called due to limits.
   InSequence s;
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection2(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection2());
   EXPECT_CALL(*connection1(), OnCanWrite()).WillOnce(Return(true));
   EXPECT_CALL(*connection2(), OnCanWrite()).WillOnce(Return(false));
   dispatcher_.OnCanWrite();
@@ -434,8 +445,9 @@ TEST_F(QuicWriteBlockedListTest, LimitedWrites) {
 TEST_F(QuicWriteBlockedListTest, TestWriteLimits) {
   // Finally make sure if we write block on a write call, we stop calling.
   InSequence s;
-  blocked_list_->insert(make_pair(connection1(), true));
-  blocked_list_->insert(make_pair(connection2(), true));
+  SetBlocked();
+  dispatcher_.OnWriteBlocked(connection1());
+  dispatcher_.OnWriteBlocked(connection2());
   EXPECT_CALL(*connection1(), OnCanWrite()).WillOnce(
       Invoke(this, &QuicWriteBlockedListTest::SetBlocked));
   EXPECT_CALL(*connection2(), OnCanWrite()).Times(0);