net/server/http_server_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6 #include <utility>
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/callback_helpers.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/format_macros.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "base/message_loop/message_loop.h"
  18 #include "base/message_loop/message_loop_proxy.h"
  19 #include "base/run_loop.h"
  20 #include "base/strings/string_split.h"
  21 #include "base/strings/string_util.h"
  22 #include "base/strings/stringprintf.h"
  23 #include "base/time/time.h"
  24 #include "net/base/address_list.h"
  25 #include "net/base/io_buffer.h"
  26 #include "net/base/ip_endpoint.h"
  27 #include "net/base/net_errors.h"
  28 #include "net/base/net_log.h"
  29 #include "net/base/net_util.h"
  30 #include "net/base/test_completion_callback.h"
  31 #include "net/http/http_response_headers.h"
  32 #include "net/http/http_util.h"
  33 #include "net/server/http_server.h"
  34 #include "net/server/http_server_request_info.h"
  35 #include "net/socket/tcp_client_socket.h"
  36 #include "net/socket/tcp_server_socket.h"
  37 #include "net/url_request/url_fetcher.h"
  38 #include "net/url_request/url_fetcher_delegate.h"
  39 #include "net/url_request/url_request_context.h"
  40 #include "net/url_request/url_request_context_getter.h"
  41 #include "net/url_request/url_request_test_util.h"
  42 #include "testing/gtest/include/gtest/gtest.h"
  43
  44 namespace net {
  45
  46 namespace {
  47
  48 const int kMaxExpectedResponseLength = 2048;
  49
  50 void SetTimedOutAndQuitLoop(const base::WeakPtr<bool> timed_out,
  51                             const base::Closure& quit_loop_func) {
  52   if (timed_out) {
  53     *timed_out = true;
  54     quit_loop_func.Run();
  55   }
  56 }
  57
  58 bool RunLoopWithTimeout(base::RunLoop* run_loop) {
  59   bool timed_out = false;
  60   base::WeakPtrFactory<bool> timed_out_weak_factory(&timed_out);
  61   base::MessageLoop::current()->PostDelayedTask(
  62       FROM_HERE,
  63       base::Bind(&SetTimedOutAndQuitLoop,
  64                  timed_out_weak_factory.GetWeakPtr(),
  65                  run_loop->QuitClosure()),
  66       base::TimeDelta::FromSeconds(1));
  67   run_loop->Run();
  68   return !timed_out;
  69 }
  70
  71 class TestHttpClient {
  72  public:
  73   TestHttpClient() : connect_result_(OK) {}
  74
  75   int ConnectAndWait(const IPEndPoint& address) {
  76     AddressList addresses(address);
  77     NetLog::Source source;
  78     socket_.reset(new TCPClientSocket(addresses, NULL, source));
  79
  80     base::RunLoop run_loop;
  81     connect_result_ = socket_->Connect(base::Bind(&TestHttpClient::OnConnect,
  82                                                   base::Unretained(this),
  83                                                   run_loop.QuitClosure()));
  84     if (connect_result_ != OK && connect_result_ != ERR_IO_PENDING)
  85       return connect_result_;
  86
  87     if (!RunLoopWithTimeout(&run_loop))
  88       return ERR_TIMED_OUT;
  89     return connect_result_;
  90   }
  91
  92   void Send(const std::string& data) {
  93     write_buffer_ =
  94         new DrainableIOBuffer(new StringIOBuffer(data), data.length());
  95     Write();
  96   }
  97
  98   bool Read(std::string* message, int expected_bytes) {
  99     int total_bytes_received = 0;
 100     message->clear();
 101     while (total_bytes_received < expected_bytes) {
 102       net::TestCompletionCallback callback;
 103       ReadInternal(callback.callback());
 104       int bytes_received = callback.WaitForResult();
 105       if (bytes_received <= 0)
 106         return false;
 107
 108       total_bytes_received += bytes_received;
 109       message->append(read_buffer_->data(), bytes_received);
 110     }
 111     return true;
 112   }
 113
 114   bool ReadResponse(std::string* message) {
 115     if (!Read(message, 1))
 116       return false;
 117     while (!IsCompleteResponse(*message)) {
 118       std::string chunk;
 119       if (!Read(&chunk, 1))
 120         return false;
 121       message->append(chunk);
 122     }
 123     return true;
 124   }
 125
 126  private:
 127   void OnConnect(const base::Closure& quit_loop, int result) {
 128     connect_result_ = result;
 129     quit_loop.Run();
 130   }
 131
 132   void Write() {
 133     int result = socket_->Write(
 134         write_buffer_.get(),
 135         write_buffer_->BytesRemaining(),
 136         base::Bind(&TestHttpClient::OnWrite, base::Unretained(this)));
 137     if (result != ERR_IO_PENDING)
 138       OnWrite(result);
 139   }
 140
 141   void OnWrite(int result) {
 142     ASSERT_GT(result, 0);
 143     write_buffer_->DidConsume(result);
 144     if (write_buffer_->BytesRemaining())
 145       Write();
 146   }
 147
 148   void ReadInternal(const net::CompletionCallback& callback) {
 149     read_buffer_ = new IOBufferWithSize(kMaxExpectedResponseLength);
 150     int result =
 151         socket_->Read(read_buffer_.get(), kMaxExpectedResponseLength, callback);
 152     if (result != ERR_IO_PENDING)
 153       callback.Run(result);
 154   }
 155
 156   bool IsCompleteResponse(const std::string& response) {
 157     // Check end of headers first.
 158     int end_of_headers = HttpUtil::LocateEndOfHeaders(response.data(),
 159                                                       response.size());
 160     if (end_of_headers < 0)
 161       return false;
 162
 163     // Return true if response has data equal to or more than content length.
 164     int64 body_size = static_cast<int64>(response.size()) - end_of_headers;
 165     DCHECK_LE(0, body_size);
 166     scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(
 167         HttpUtil::AssembleRawHeaders(response.data(), end_of_headers)));
 168     return body_size >= headers->GetContentLength();
 169   }
 170
 171   scoped_refptr<IOBufferWithSize> read_buffer_;
 172   scoped_refptr<DrainableIOBuffer> write_buffer_;
 173   scoped_ptr<TCPClientSocket> socket_;
 174   int connect_result_;
 175 };
 176
 177 }  // namespace
 178
 179 class HttpServerTest : public testing::Test,
 180                        public HttpServer::Delegate {
 181  public:
 182   HttpServerTest() : quit_after_request_count_(0) {}
 183
 184   virtual void SetUp() OVERRIDE {
 185     scoped_ptr<ServerSocket> server_socket(
 186         new TCPServerSocket(NULL, net::NetLog::Source()));
 187     server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
 188     server_.reset(new HttpServer(server_socket.Pass(), this));
 189     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
 190   }
 191
 192   virtual void OnHttpRequest(int connection_id,
 193                              const HttpServerRequestInfo& info) OVERRIDE {
 194     requests_.push_back(std::make_pair(info, connection_id));
 195     if (requests_.size() == quit_after_request_count_)
 196       run_loop_quit_func_.Run();
 197   }
 198
 199   virtual void OnWebSocketRequest(int connection_id,
 200                                   const HttpServerRequestInfo& info) OVERRIDE {
 201     NOTREACHED();
 202   }
 203
 204   virtual void OnWebSocketMessage(int connection_id,
 205                                   const std::string& data) OVERRIDE {
 206     NOTREACHED();
 207   }
 208
 209   virtual void OnClose(int connection_id) OVERRIDE {}
 210
 211   bool RunUntilRequestsReceived(size_t count) {
 212     quit_after_request_count_ = count;
 213     if (requests_.size() == count)
 214       return true;
 215
 216     base::RunLoop run_loop;
 217     run_loop_quit_func_ = run_loop.QuitClosure();
 218     bool success = RunLoopWithTimeout(&run_loop);
 219     run_loop_quit_func_.Reset();
 220     return success;
 221   }
 222
 223   HttpServerRequestInfo GetRequest(size_t request_index) {
 224     return requests_[request_index].first;
 225   }
 226
 227   int GetConnectionId(size_t request_index) {
 228     return requests_[request_index].second;
 229   }
 230
 231   void HandleAcceptResult(scoped_ptr<StreamSocket> socket) {
 232     server_->accepted_socket_.reset(socket.release());
 233     server_->HandleAcceptResult(OK);
 234   }
 235
 236  protected:
 237   scoped_ptr<HttpServer> server_;
 238   IPEndPoint server_address_;
 239   base::Closure run_loop_quit_func_;
 240   std::vector<std::pair<HttpServerRequestInfo, int> > requests_;
 241
 242  private:
 243   size_t quit_after_request_count_;
 244 };
 245
 246 class WebSocketTest : public HttpServerTest {
 247   virtual void OnHttpRequest(int connection_id,
 248                              const HttpServerRequestInfo& info) OVERRIDE {
 249     NOTREACHED();
 250   }
 251
 252   virtual void OnWebSocketRequest(int connection_id,
 253                                   const HttpServerRequestInfo& info) OVERRIDE {
 254     HttpServerTest::OnHttpRequest(connection_id, info);
 255   }
 256
 257   virtual void OnWebSocketMessage(int connection_id,
 258                                   const std::string& data) OVERRIDE {
 259   }
 260 };
 261
 262 TEST_F(HttpServerTest, Request) {
 263   TestHttpClient client;
 264   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 265   client.Send("GET /test HTTP/1.1\r\n\r\n");
 266   ASSERT_TRUE(RunUntilRequestsReceived(1));
 267   ASSERT_EQ("GET", GetRequest(0).method);
 268   ASSERT_EQ("/test", GetRequest(0).path);
 269   ASSERT_EQ("", GetRequest(0).data);
 270   ASSERT_EQ(0u, GetRequest(0).headers.size());
 271   ASSERT_TRUE(StartsWithASCII(GetRequest(0).peer.ToString(),
 272                               "127.0.0.1",
 273                               true));
 274 }
 275
 276 TEST_F(HttpServerTest, RequestWithHeaders) {
 277   TestHttpClient client;
 278   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 279   const char* kHeaders[][3] = {
 280       {"Header", ": ", "1"},
 281       {"HeaderWithNoWhitespace", ":", "1"},
 282       {"HeaderWithWhitespace", "   :  \t   ", "1 1 1 \t  "},
 283       {"HeaderWithColon", ": ", "1:1"},
 284       {"EmptyHeader", ":", ""},
 285       {"EmptyHeaderWithWhitespace", ":  \t  ", ""},
 286       {"HeaderWithNonASCII", ":  ", "\xf7"},
 287   };
 288   std::string headers;
 289   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
 290     headers +=
 291         std::string(kHeaders[i][0]) + kHeaders[i][1] + kHeaders[i][2] + "\r\n";
 292   }
 293
 294   client.Send("GET /test HTTP/1.1\r\n" + headers + "\r\n");
 295   ASSERT_TRUE(RunUntilRequestsReceived(1));
 296   ASSERT_EQ("", GetRequest(0).data);
 297
 298   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
 299     std::string field = base::StringToLowerASCII(std::string(kHeaders[i][0]));
 300     std::string value = kHeaders[i][2];
 301     ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
 302     ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
 303   }
 304 }
 305
 306 TEST_F(HttpServerTest, RequestWithDuplicateHeaders) {
 307   TestHttpClient client;
 308   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 309   const char* kHeaders[][3] = {
 310       {"FirstHeader", ": ", "1"},
 311       {"DuplicateHeader", ": ", "2"},
 312       {"MiddleHeader", ": ", "3"},
 313       {"DuplicateHeader", ": ", "4"},
 314       {"LastHeader", ": ", "5"},
 315   };
 316   std::string headers;
 317   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
 318     headers +=
 319         std::string(kHeaders[i][0]) + kHeaders[i][1] + kHeaders[i][2] + "\r\n";
 320   }
 321
 322   client.Send("GET /test HTTP/1.1\r\n" + headers + "\r\n");
 323   ASSERT_TRUE(RunUntilRequestsReceived(1));
 324   ASSERT_EQ("", GetRequest(0).data);
 325
 326   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
 327     std::string field = base::StringToLowerASCII(std::string(kHeaders[i][0]));
 328     std::string value = (field == "duplicateheader") ? "2,4" : kHeaders[i][2];
 329     ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
 330     ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
 331   }
 332 }
 333
 334 TEST_F(HttpServerTest, HasHeaderValueTest) {
 335   TestHttpClient client;
 336   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 337   const char* kHeaders[] = {
 338       "Header: Abcd",
 339       "HeaderWithNoWhitespace:E",
 340       "HeaderWithWhitespace   :  \t   f \t  ",
 341       "DuplicateHeader: g",
 342       "HeaderWithComma: h, i ,j",
 343       "DuplicateHeader: k",
 344       "EmptyHeader:",
 345       "EmptyHeaderWithWhitespace:  \t  ",
 346       "HeaderWithNonASCII:  \xf7",
 347   };
 348   std::string headers;
 349   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
 350     headers += std::string(kHeaders[i]) + "\r\n";
 351   }
 352
 353   client.Send("GET /test HTTP/1.1\r\n" + headers + "\r\n");
 354   ASSERT_TRUE(RunUntilRequestsReceived(1));
 355   ASSERT_EQ("", GetRequest(0).data);
 356
 357   ASSERT_TRUE(GetRequest(0).HasHeaderValue("header", "abcd"));
 358   ASSERT_FALSE(GetRequest(0).HasHeaderValue("header", "bc"));
 359   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithnowhitespace", "e"));
 360   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithwhitespace", "f"));
 361   ASSERT_TRUE(GetRequest(0).HasHeaderValue("duplicateheader", "g"));
 362   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithcomma", "h"));
 363   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithcomma", "i"));
 364   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithcomma", "j"));
 365   ASSERT_TRUE(GetRequest(0).HasHeaderValue("duplicateheader", "k"));
 366   ASSERT_FALSE(GetRequest(0).HasHeaderValue("emptyheader", "x"));
 367   ASSERT_FALSE(GetRequest(0).HasHeaderValue("emptyheaderwithwhitespace", "x"));
 368   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithnonascii", "\xf7"));
 369 }
 370
 371 TEST_F(HttpServerTest, RequestWithBody) {
 372   TestHttpClient client;
 373   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 374   std::string body = "a" + std::string(1 << 10, 'b') + "c";
 375   client.Send(base::StringPrintf(
 376       "GET /test HTTP/1.1\r\n"
 377       "SomeHeader: 1\r\n"
 378       "Content-Length: %" PRIuS "\r\n\r\n%s",
 379       body.length(),
 380       body.c_str()));
 381   ASSERT_TRUE(RunUntilRequestsReceived(1));
 382   ASSERT_EQ(2u, GetRequest(0).headers.size());
 383   ASSERT_EQ(body.length(), GetRequest(0).data.length());
 384   ASSERT_EQ('a', body[0]);
 385   ASSERT_EQ('c', *body.rbegin());
 386 }
 387
 388 TEST_F(WebSocketTest, RequestWebSocket) {
 389   TestHttpClient client;
 390   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 391   client.Send(
 392       "GET /test HTTP/1.1\r\n"
 393       "Upgrade: WebSocket\r\n"
 394       "Connection: SomethingElse, Upgrade\r\n"
 395       "Sec-WebSocket-Version: 8\r\n"
 396       "Sec-WebSocket-Key: key\r\n"
 397       "\r\n");
 398   ASSERT_TRUE(RunUntilRequestsReceived(1));
 399 }
 400
 401 TEST_F(HttpServerTest, RequestWithTooLargeBody) {
 402   class TestURLFetcherDelegate : public URLFetcherDelegate {
 403    public:
 404     TestURLFetcherDelegate(const base::Closure& quit_loop_func)
 405         : quit_loop_func_(quit_loop_func) {}
 406     virtual ~TestURLFetcherDelegate() {}
 407
 408     virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
 409       EXPECT_EQ(HTTP_INTERNAL_SERVER_ERROR, source->GetResponseCode());
 410       quit_loop_func_.Run();
 411     }
 412
 413    private:
 414     base::Closure quit_loop_func_;
 415   };
 416
 417   base::RunLoop run_loop;
 418   TestURLFetcherDelegate delegate(run_loop.QuitClosure());
 419
 420   scoped_refptr<URLRequestContextGetter> request_context_getter(
 421       new TestURLRequestContextGetter(base::MessageLoopProxy::current()));
 422   scoped_ptr<URLFetcher> fetcher(
 423       URLFetcher::Create(GURL(base::StringPrintf("http://127.0.0.1:%d/test",
 424                                                  server_address_.port())),
 425                          URLFetcher::GET,
 426                          &delegate));
 427   fetcher->SetRequestContext(request_context_getter.get());
 428   fetcher->AddExtraRequestHeader(
 429       base::StringPrintf("content-length:%d", 1 << 30));
 430   fetcher->Start();
 431
 432   ASSERT_TRUE(RunLoopWithTimeout(&run_loop));
 433   ASSERT_EQ(0u, requests_.size());
 434 }
 435
 436 TEST_F(HttpServerTest, Send200) {
 437   TestHttpClient client;
 438   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 439   client.Send("GET /test HTTP/1.1\r\n\r\n");
 440   ASSERT_TRUE(RunUntilRequestsReceived(1));
 441   server_->Send200(GetConnectionId(0), "Response!", "text/plain");
 442
 443   std::string response;
 444   ASSERT_TRUE(client.ReadResponse(&response));
 445   ASSERT_TRUE(StartsWithASCII(response, "HTTP/1.1 200 OK", true));
 446   ASSERT_TRUE(EndsWith(response, "Response!", true));
 447 }
 448
 449 TEST_F(HttpServerTest, SendRaw) {
 450   TestHttpClient client;
 451   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 452   client.Send("GET /test HTTP/1.1\r\n\r\n");
 453   ASSERT_TRUE(RunUntilRequestsReceived(1));
 454   server_->SendRaw(GetConnectionId(0), "Raw Data ");
 455   server_->SendRaw(GetConnectionId(0), "More Data");
 456   server_->SendRaw(GetConnectionId(0), "Third Piece of Data");
 457
 458   const std::string expected_response("Raw Data More DataThird Piece of Data");
 459   std::string response;
 460   ASSERT_TRUE(client.Read(&response, expected_response.length()));
 461   ASSERT_EQ(expected_response, response);
 462 }
 463
 464 namespace {
 465
 466 class MockStreamSocket : public StreamSocket {
 467  public:
 468   MockStreamSocket()
 469       : connected_(true),
 470         read_buf_(NULL),
 471         read_buf_len_(0) {}
 472
 473   // StreamSocket
 474   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
 475     return ERR_NOT_IMPLEMENTED;
 476   }
 477   virtual void Disconnect() OVERRIDE {
 478     connected_ = false;
 479     if (!read_callback_.is_null()) {
 480       read_buf_ = NULL;
 481       read_buf_len_ = 0;
 482       base::ResetAndReturn(&read_callback_).Run(ERR_CONNECTION_CLOSED);
 483     }
 484   }
 485   virtual bool IsConnected() const OVERRIDE { return connected_; }
 486   virtual bool IsConnectedAndIdle() const OVERRIDE { return IsConnected(); }
 487   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
 488     return ERR_NOT_IMPLEMENTED;
 489   }
 490   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
 491     return ERR_NOT_IMPLEMENTED;
 492   }
 493   virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
 494   virtual void SetSubresourceSpeculation() OVERRIDE {}
 495   virtual void SetOmniboxSpeculation() OVERRIDE {}
 496   virtual bool WasEverUsed() const OVERRIDE { return true; }
 497   virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
 498   virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
 499   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
 500     return kProtoUnknown;
 501   }
 502   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
 503
 504   // Socket
 505   virtual int Read(IOBuffer* buf, int buf_len,
 506                    const CompletionCallback& callback) OVERRIDE {
 507     if (!connected_) {
 508       return ERR_SOCKET_NOT_CONNECTED;
 509     }
 510     if (pending_read_data_.empty()) {
 511       read_buf_ = buf;
 512       read_buf_len_ = buf_len;
 513       read_callback_ = callback;
 514       return ERR_IO_PENDING;
 515     }
 516     DCHECK_GT(buf_len, 0);
 517     int read_len = std::min(static_cast<int>(pending_read_data_.size()),
 518                             buf_len);
 519     memcpy(buf->data(), pending_read_data_.data(), read_len);
 520     pending_read_data_.erase(0, read_len);
 521     return read_len;
 522   }
 523   virtual int Write(IOBuffer* buf, int buf_len,
 524                     const CompletionCallback& callback) OVERRIDE {
 525     return ERR_NOT_IMPLEMENTED;
 526   }
 527   virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
 528     return ERR_NOT_IMPLEMENTED;
 529   }
 530   virtual int SetSendBufferSize(int32 size) OVERRIDE {
 531     return ERR_NOT_IMPLEMENTED;
 532   }
 533
 534   void DidRead(const char* data, int data_len) {
 535     if (!read_buf_.get()) {
 536       pending_read_data_.append(data, data_len);
 537       return;
 538     }
 539     int read_len = std::min(data_len, read_buf_len_);
 540     memcpy(read_buf_->data(), data, read_len);
 541     pending_read_data_.assign(data + read_len, data_len - read_len);
 542     read_buf_ = NULL;
 543     read_buf_len_ = 0;
 544     base::ResetAndReturn(&read_callback_).Run(read_len);
 545   }
 546
 547  private:
 548   virtual ~MockStreamSocket() {}
 549
 550   bool connected_;
 551   scoped_refptr<IOBuffer> read_buf_;
 552   int read_buf_len_;
 553   CompletionCallback read_callback_;
 554   std::string pending_read_data_;
 555   BoundNetLog net_log_;
 556
 557   DISALLOW_COPY_AND_ASSIGN(MockStreamSocket);
 558 };
 559
 560 }  // namespace
 561
 562 TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
 563   MockStreamSocket* socket = new MockStreamSocket();
 564   HandleAcceptResult(make_scoped_ptr<StreamSocket>(socket));
 565   std::string body("body");
 566   std::string request_text = base::StringPrintf(
 567       "GET /test HTTP/1.1\r\n"
 568       "SomeHeader: 1\r\n"
 569       "Content-Length: %" PRIuS "\r\n\r\n%s",
 570       body.length(),
 571       body.c_str());
 572   socket->DidRead(request_text.c_str(), request_text.length() - 2);
 573   ASSERT_EQ(0u, requests_.size());
 574   socket->DidRead(request_text.c_str() + request_text.length() - 2, 2);
 575   ASSERT_EQ(1u, requests_.size());
 576   ASSERT_EQ(body, GetRequest(0).data);
 577 }
 578
 579 TEST_F(HttpServerTest, MultipleRequestsOnSameConnection) {
 580   // The idea behind this test is that requests with or without bodies should
 581   // not break parsing of the next request.
 582   TestHttpClient client;
 583   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
 584   std::string body = "body";
 585   client.Send(base::StringPrintf(
 586       "GET /test HTTP/1.1\r\n"
 587       "Content-Length: %" PRIuS "\r\n\r\n%s",
 588       body.length(),
 589       body.c_str()));
 590   ASSERT_TRUE(RunUntilRequestsReceived(1));
 591   ASSERT_EQ(body, GetRequest(0).data);
 592
 593   int client_connection_id = GetConnectionId(0);
 594   server_->Send200(client_connection_id, "Content for /test", "text/plain");
 595   std::string response1;
 596   ASSERT_TRUE(client.ReadResponse(&response1));
 597   ASSERT_TRUE(StartsWithASCII(response1, "HTTP/1.1 200 OK", true));
 598   ASSERT_TRUE(EndsWith(response1, "Content for /test", true));
 599
 600   client.Send("GET /test2 HTTP/1.1\r\n\r\n");
 601   ASSERT_TRUE(RunUntilRequestsReceived(2));
 602   ASSERT_EQ("/test2", GetRequest(1).path);
 603
 604   ASSERT_EQ(client_connection_id, GetConnectionId(1));
 605   server_->Send404(client_connection_id);
 606   std::string response2;
 607   ASSERT_TRUE(client.ReadResponse(&response2));
 608   ASSERT_TRUE(StartsWithASCII(response2, "HTTP/1.1 404 Not Found", true));
 609
 610   client.Send("GET /test3 HTTP/1.1\r\n\r\n");
 611   ASSERT_TRUE(RunUntilRequestsReceived(3));
 612   ASSERT_EQ("/test3", GetRequest(2).path);
 613
 614   ASSERT_EQ(client_connection_id, GetConnectionId(2));
 615   server_->Send200(client_connection_id, "Content for /test3", "text/plain");
 616   std::string response3;
 617   ASSERT_TRUE(client.ReadResponse(&response3));
 618   ASSERT_TRUE(StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
 619   ASSERT_TRUE(EndsWith(response3, "Content for /test3", true));
 620 }
 621
 622 }  // namespace net