Add net::HttpServer::Delegate::OnConnect() function and set ChromeDriver buffer sizes to 100 MB

net/server/http_server_unittest.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 <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 171 matching lines @@
   HttpServerTest() : quit_after_request_count_(0) {}
 
   virtual void SetUp() OVERRIDE {
     scoped_ptr<ServerSocket> server_socket(
         new TCPServerSocket(NULL, net::NetLog::Source()));
     server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
     server_.reset(new HttpServer(server_socket.Pass(), this));
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
+  virtual void OnConnect(int connection_id) OVERRIDE {}
+
   virtual void OnHttpRequest(int connection_id,
                              const HttpServerRequestInfo& info) OVERRIDE {
     requests_.push_back(std::make_pair(info, connection_id));
     if (requests_.size() == quit_after_request_count_)
       run_loop_quit_func_.Run();
   }
 
   virtual void OnWebSocketRequest(int connection_id,
                                   const HttpServerRequestInfo& info) OVERRIDE {
     NOTREACHED();
@@ skipping 34 matching lines @@
  protected:
   scoped_ptr<HttpServer> server_;
   IPEndPoint server_address_;
   base::Closure run_loop_quit_func_;
   std::vector<std::pair<HttpServerRequestInfo, int> > requests_;
 
  private:
   size_t quit_after_request_count_;
 };
 
+namespace {
+
 class WebSocketTest : public HttpServerTest {
   virtual void OnHttpRequest(int connection_id,
                              const HttpServerRequestInfo& info) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void OnWebSocketRequest(int connection_id,
                                   const HttpServerRequestInfo& info) OVERRIDE {
     HttpServerTest::OnHttpRequest(connection_id, info);
   }
@@ skipping 198 matching lines @@
   server_->SendRaw(GetConnectionId(0), "Raw Data ");
   server_->SendRaw(GetConnectionId(0), "More Data");
   server_->SendRaw(GetConnectionId(0), "Third Piece of Data");
 
   const std::string expected_response("Raw Data More DataThird Piece of Data");
   std::string response;
   ASSERT_TRUE(client.Read(&response, expected_response.length()));
   ASSERT_EQ(expected_response, response);
 }
 
-namespace {
-
 class MockStreamSocket : public StreamSocket {
  public:
   MockStreamSocket()
       : connected_(true),
         read_buf_(NULL),
         read_buf_len_(0) {}
 
   // StreamSocket
   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
     return ERR_NOT_IMPLEMENTED;
@@ skipping 74 matching lines @@
   bool connected_;
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
   CompletionCallback read_callback_;
   std::string pending_read_data_;
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(MockStreamSocket);
 };
 
-}  // namespace
-
 TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
   MockStreamSocket* socket = new MockStreamSocket();
   HandleAcceptResult(make_scoped_ptr<StreamSocket>(socket));
   std::string body("body");
   std::string request_text = base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "SomeHeader: 1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str());
@@ skipping 40 matching lines @@
   ASSERT_EQ("/test3", GetRequest(2).path);
 
   ASSERT_EQ(client_connection_id, GetConnectionId(2));
   server_->Send200(client_connection_id, "Content for /test3", "text/plain");
   std::string response3;
   ASSERT_TRUE(client.ReadResponse(&response3));
   ASSERT_TRUE(StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
   ASSERT_TRUE(EndsWith(response3, "Content for /test3", true));
 }
 
+class CloseOnConnectHttpServerTest : public HttpServerTest {
+ public:
+  virtual void OnConnect(int connection_id) OVERRIDE {
+    connection_ids_.push_back(connection_id);
+    server_->Close(connection_id);
+  }
+
+ protected:
+  std::vector<int> connection_ids_;
+};
+
+TEST_F(CloseOnConnectHttpServerTest, ServerImmediatelyClosesConnection) {
+  TestHttpClient client;
+  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_EQ(1ul, connection_ids_.size());
+  client.Send("GET / HTTP/1.1\r\n\r\n");
+  ASSERT_FALSE(RunUntilRequestsReceived(1));
+  ASSERT_EQ(0ul, requests_.size());
+}
+
+}  // namespace
+
 }  // namespace net