original change

net/websockets/websocket_throttle_test.cc

 // Copyright 2013 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 "net/websockets/websocket_throttle.h"
 
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "net/base/address_list.h"
@@ skipping 55 matching lines @@
   // configuration.
   WebSocketJob::set_websocket_over_spdy_enabled(true);
 
   // For host1: 1.2.3.4, 1.2.3.5, 1.2.3.6
   AddressList addr;
   addr.push_back(MakeAddr(1, 2, 3, 4));
   addr.push_back(MakeAddr(1, 2, 3, 5));
   addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
-      new SocketStream(GURL("ws://host1/"), w1.get()));
-  s1->set_context(&context);
+      new SocketStream(GURL("ws://host1/"), w1.get(), &context, NULL));
   w1->InitSocketStream(s1.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s1.get(), addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to host1 will start without wait.
   EXPECT_EQ(OK, w1->OnStartOpenConnection(s1.get(), callback_s1.callback()));
 
   // Now connecting to host1, so waiting queue looks like
   // Address | head -> tail
   // 1.2.3.4 | w1
   // 1.2.3.5 | w1
   // 1.2.3.6 | w1
 
   // For host2: 1.2.3.4
   addr.clear();
   addr.push_back(MakeAddr(1, 2, 3, 4));
   scoped_refptr<WebSocketJob> w2(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s2(
-      new SocketStream(GURL("ws://host2/"), w2.get()));
-  s2->set_context(&context);
+      new SocketStream(GURL("ws://host2/"), w2.get(), &context, NULL));
   w2->InitSocketStream(s2.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s2.get(), addr);
 
   DVLOG(1) << "socket2";
   TestCompletionCallback callback_s2;
   // Trying to open connection to host2 will wait for w1.
   EXPECT_EQ(ERR_IO_PENDING,
             w2->OnStartOpenConnection(s2.get(), callback_s2.callback()));
   // Now waiting queue looks like
   // Address | head -> tail
   // 1.2.3.4 | w1 w2
   // 1.2.3.5 | w1
   // 1.2.3.6 | w1
 
   // For host3: 1.2.3.5
   addr.clear();
   addr.push_back(MakeAddr(1, 2, 3, 5));
   scoped_refptr<WebSocketJob> w3(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s3(
-      new SocketStream(GURL("ws://host3/"), w3.get()));
-  s3->set_context(&context);
+      new SocketStream(GURL("ws://host3/"), w3.get(), &context, NULL));
   w3->InitSocketStream(s3.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s3.get(), addr);
 
   DVLOG(1) << "socket3";
   TestCompletionCallback callback_s3;
   // Trying to open connection to host3 will wait for w1.
   EXPECT_EQ(ERR_IO_PENDING,
             w3->OnStartOpenConnection(s3.get(), callback_s3.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2
   // 1.2.3.5 | w1    w3
   // 1.2.3.6 | w1
 
   // For host4: 1.2.3.4, 1.2.3.6
   addr.clear();
   addr.push_back(MakeAddr(1, 2, 3, 4));
   addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w4(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s4(
-      new SocketStream(GURL("ws://host4/"), w4.get()));
-  s4->set_context(&context);
+      new SocketStream(GURL("ws://host4/"), w4.get(), &context, NULL));
   w4->InitSocketStream(s4.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s4.get(), addr);
 
   DVLOG(1) << "socket4";
   TestCompletionCallback callback_s4;
   // Trying to open connection to host4 will wait for w1, w2.
   EXPECT_EQ(ERR_IO_PENDING,
             w4->OnStartOpenConnection(s4.get(), callback_s4.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
   // 1.2.3.5 | w1    w3
   // 1.2.3.6 | w1       w4
 
   // For host5: 1.2.3.6
   addr.clear();
   addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w5(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s5(
-      new SocketStream(GURL("ws://host5/"), w5.get()));
-  s5->set_context(&context);
+      new SocketStream(GURL("ws://host5/"), w5.get(), &context, NULL));
   w5->InitSocketStream(s5.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s5.get(), addr);
 
   DVLOG(1) << "socket5";
   TestCompletionCallback callback_s5;
   // Trying to open connection to host5 will wait for w1, w4
   EXPECT_EQ(ERR_IO_PENDING,
             w5->OnStartOpenConnection(s5.get(), callback_s5.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
   // 1.2.3.5 | w1    w3
   // 1.2.3.6 | w1       w4 w5
 
   // For host6: 1.2.3.6
   addr.clear();
   addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w6(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s6(
-      new SocketStream(GURL("ws://host6/"), w6.get()));
-  s6->set_context(&context);
+      new SocketStream(GURL("ws://host6/"), w6.get(), &context, NULL));
   w6->InitSocketStream(s6.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s6.get(), addr);
 
   DVLOG(1) << "socket6";
   TestCompletionCallback callback_s6;
   // Trying to open connection to host6 will wait for w1, w4, w5
   EXPECT_EQ(ERR_IO_PENDING,
             w6->OnStartOpenConnection(s6.get(), callback_s6.callback()));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
@@ skipping 91 matching lines @@
   TestURLRequestContext context;
   DummySocketStreamDelegate delegate;
   WebSocketJob::set_websocket_over_spdy_enabled(true);
 
   // For localhost: 127.0.0.1, 127.0.0.1
   AddressList addr;
   addr.push_back(MakeAddr(127, 0, 0, 1));
   addr.push_back(MakeAddr(127, 0, 0, 1));
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
-      new SocketStream(GURL("ws://localhost/"), w1.get()));
-  s1->set_context(&context);
+      new SocketStream(GURL("ws://localhost/"), w1.get(), &context, NULL));
   w1->InitSocketStream(s1.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s1.get(), addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to localhost will start without wait.
   EXPECT_EQ(OK, w1->OnStartOpenConnection(s1.get(), callback_s1.callback()));
 
   DVLOG(1) << "socket1 close";
   w1->OnClose(s1.get());
   s1->DetachDelegate();
   DVLOG(1) << "Done";
   base::MessageLoopForIO::current()->RunUntilIdle();
 }
 
 // A connection should not be blocked by another connection to the same IP
 // with a different port.
 TEST_F(WebSocketThrottleTest, NoThrottleForDistinctPort) {
   TestURLRequestContext context;
   DummySocketStreamDelegate delegate;
   IPAddressNumber localhost;
   ParseIPLiteralToNumber("127.0.0.1", &localhost);
   WebSocketJob::set_websocket_over_spdy_enabled(false);
 
   // socket1: 127.0.0.1:80
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
-      new SocketStream(GURL("ws://localhost:80/"), w1.get()));
-  s1->set_context(&context);
+      new SocketStream(GURL("ws://localhost:80/"), w1.get(), &context, NULL));
   w1->InitSocketStream(s1.get());
   MockSocketStreamConnect(s1.get(),
                           AddressList::CreateFromIPAddress(localhost, 80));
 
   DVLOG(1) << "connecting socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to localhost:80 will start without waiting.
   EXPECT_EQ(OK, w1->OnStartOpenConnection(s1.get(), callback_s1.callback()));
 
   // socket2: 127.0.0.1:81
   scoped_refptr<WebSocketJob> w2(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s2(
-      new SocketStream(GURL("ws://localhost:81/"), w2.get()));
-  s2->set_context(&context);
+      new SocketStream(GURL("ws://localhost:81/"), w2.get(), &context, NULL));
   w2->InitSocketStream(s2.get());
   MockSocketStreamConnect(s2.get(),
                           AddressList::CreateFromIPAddress(localhost, 81));
 
   DVLOG(1) << "connecting socket2";
   TestCompletionCallback callback_s2;
   // Trying to open connection to localhost:81 will start without waiting.
   EXPECT_EQ(OK, w2->OnStartOpenConnection(s2.get(), callback_s2.callback()));
 
   DVLOG(1) << "closing socket1";
   w1->OnClose(s1.get());
   s1->DetachDelegate();
 
   DVLOG(1) << "closing socket2";
   w2->OnClose(s2.get());
   s2->DetachDelegate();
   DVLOG(1) << "Done";
   base::MessageLoopForIO::current()->RunUntilIdle();
 }
 
 }