WebSocket over SPDY.

net/websockets/websocket_throttle_unittest.cc

 // Copyright (c) 2010 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 <string>
 
 #include "base/message_loop.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/address_list.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket_stream/socket_stream.h"
+#include "net/url_request/url_request_unittest.h"
 #include "net/websockets/websocket_job.h"
 #include "net/websockets/websocket_throttle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 class DummySocketStreamDelegate : public net::SocketStream::Delegate {
  public:
   DummySocketStreamDelegate() {}
   virtual ~DummySocketStreamDelegate() {}
   virtual void OnConnected(
@@ skipping 34 matching lines @@
     for (struct addrinfo* a = head; a != NULL; a = next) {
       next = a->ai_next;
       delete [] a->ai_addr;
       delete a;
     }
   }
 
   static void MockSocketStreamConnect(
       SocketStream* socket, struct addrinfo* head) {
     socket->CopyAddrInfo(head);
+    // Initialize |proxy_info_|.
+    socket->proxy_info_.UseDirect();
     // In SocketStream::Connect(), it adds reference to socket, which is
     // balanced with SocketStream::Finish() that is finally called from
     // SocketStream::Close() or SocketStream::DetachDelegate(), when
     // next_state_ is not STATE_NONE.
     // If next_state_ is STATE_NONE, SocketStream::Close() or
     // SocketStream::DetachDelegate() won't call SocketStream::Finish(),
     // so Release() won't be called.  Thus, we don't need socket->AddRef()
     // here.
     DCHECK_EQ(socket->next_state_, SocketStream::STATE_NONE);
   }
 };
 
 TEST_F(WebSocketThrottleTest, Throttle) {
+  scoped_refptr<URLRequestContext> context(new TestURLRequestContext);
   DummySocketStreamDelegate delegate;
 
   // For host1: 1.2.3.4, 1.2.3.5, 1.2.3.6
   struct addrinfo* addr = AddAddr(1, 2, 3, 4, NULL);
   addr = AddAddr(1, 2, 3, 5, addr);
   addr = AddAddr(1, 2, 3, 6, addr);
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
       new SocketStream(GURL("ws://host1/"), w1.get()));
+  s1->set_context(context.get());
   w1->InitSocketStream(s1.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s1, addr);
   DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to host1 will start without wait.
   EXPECT_EQ(OK, w1->OnStartOpenConnection(s1, &callback_s1));
 
   // 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 = AddAddr(1, 2, 3, 4, NULL);
   scoped_refptr<WebSocketJob> w2(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s2(
       new SocketStream(GURL("ws://host2/"), w2.get()));
+  s2->set_context(context.get());
   w2->InitSocketStream(s2.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s2, addr);
   DeleteAddrInfo(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, &callback_s2));
   // 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 = AddAddr(1, 2, 3, 5, NULL);
   scoped_refptr<WebSocketJob> w3(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s3(
       new SocketStream(GURL("ws://host3/"), w3.get()));
+  s3->set_context(context.get());
   w3->InitSocketStream(s3.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s3, addr);
   DeleteAddrInfo(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, &callback_s3));
   // 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 = AddAddr(1, 2, 3, 4, NULL);
   addr = AddAddr(1, 2, 3, 6, addr);
   scoped_refptr<WebSocketJob> w4(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s4(
       new SocketStream(GURL("ws://host4/"), w4.get()));
+  s4->set_context(context.get());
   w4->InitSocketStream(s4.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s4, addr);
   DeleteAddrInfo(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, &callback_s4));
   // 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 = AddAddr(1, 2, 3, 6, NULL);
   scoped_refptr<WebSocketJob> w5(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s5(
       new SocketStream(GURL("ws://host5/"), w5.get()));
+  s5->set_context(context.get());
   w5->InitSocketStream(s5.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s5, addr);
   DeleteAddrInfo(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, &callback_s5));
   // 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 = AddAddr(1, 2, 3, 6, NULL);
   scoped_refptr<WebSocketJob> w6(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s6(
       new SocketStream(GURL("ws://host6/"), w6.get()));
+  s6->set_context(context.get());
   w6->InitSocketStream(s6.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s6, addr);
   DeleteAddrInfo(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, &callback_s6));
   // Address | head -> tail
   // 1.2.3.4 | w1 w2    w4
@@ skipping 81 matching lines @@
   w3->OnClose(s3.get());
   MessageLoopForIO::current()->RunAllPending();
   s3->DetachDelegate();
   w4->OnClose(s4.get());
   s4->DetachDelegate();
   DVLOG(1) << "Done";
   MessageLoopForIO::current()->RunAllPending();
 }
 
 TEST_F(WebSocketThrottleTest, NoThrottleForDuplicateAddress) {
+  scoped_refptr<URLRequestContext> context(new TestURLRequestContext);
   DummySocketStreamDelegate delegate;
 
   // For localhost: 127.0.0.1, 127.0.0.1
   struct addrinfo* addr = AddAddr(127, 0, 0, 1, NULL);
   addr = AddAddr(127, 0, 0, 1, addr);
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
       new SocketStream(GURL("ws://localhost/"), w1.get()));
+  s1->set_context(context.get());
   w1->InitSocketStream(s1.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s1, addr);
   DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
   // Trying to open connection to localhost will start without wait.
   EXPECT_EQ(OK, w1->OnStartOpenConnection(s1, &callback_s1));
 
   DVLOG(1) << "socket1 close";
   w1->OnClose(s1.get());
   s1->DetachDelegate();
   DVLOG(1) << "Done";
   MessageLoopForIO::current()->RunAllPending();
 }
 
 }