Refuse to pipeline frames, prefetches, and downloads.

net/http/http_pipelined_network_transaction_unittest.cc

 // Copyright (c) 2012 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/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 95 matching lines @@
     DeterministicSocketData* data = new DeterministicSocketData(
         reads, reads_count, writes, writes_count);
     data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     if (reads_count || writes_count) {
       data->StopAfter(reads_count + writes_count);
     }
     factory_.AddSocketDataProvider(data);
     data_vector_.push_back(data);
   }
 
-  HttpRequestInfo* GetRequestInfo(const char* filename) {
+  enum RequestInfoOptions {
+    REQUEST_DEFAULT,
+    REQUEST_MAIN_RESOURCE,
+  };
+
+  HttpRequestInfo* GetRequestInfo(
+      const char* filename, RequestInfoOptions options = REQUEST_DEFAULT) {
     std::string url = StringPrintf("http://localhost/%s", filename);
     HttpRequestInfo* request_info = new HttpRequestInfo;
     request_info->url = GURL(url);
     request_info->method = "GET";
+    if (options == REQUEST_MAIN_RESOURCE) {
+      request_info->load_flags = LOAD_MAIN_FRAME;
+    }
     request_info_vector_.push_back(request_info);
     return request_info;
   }
 
   void ExpectResponse(const std::string& expected,
                       HttpNetworkTransaction& transaction,
                       IoMode io_mode) {
     scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
     if (io_mode == ASYNC) {
       EXPECT_EQ(ERR_IO_PENDING, transaction.Read(buffer.get(), expected.size(),
@@ skipping 38 matching lines @@
     data_vector_[data_index]->SetStop(10);
     std::string actual(buffer->data(), 8);
     EXPECT_THAT(actual, StrEq("one.html"));
     EXPECT_EQ(OK, one_transaction->Read(buffer.get(), 8,
                                         one_read_callback.callback()));
 
     EXPECT_EQ(OK, two_callback.WaitForResult());
     ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
   }
 
-  void CompleteFourRequests() {
+  void CompleteFourRequests(RequestInfoOptions options) {
     scoped_ptr<HttpNetworkTransaction> one_transaction(
         new HttpNetworkTransaction(session_.get()));
     TestCompletionCallback one_callback;
     EXPECT_EQ(ERR_IO_PENDING,
-              one_transaction->Start(GetRequestInfo("one.html"),
+              one_transaction->Start(GetRequestInfo("one.html", options),
                                      one_callback.callback(), BoundNetLog()));
     EXPECT_EQ(OK, one_callback.WaitForResult());
 
     HttpNetworkTransaction two_transaction(session_.get());
     TestCompletionCallback two_callback;
     EXPECT_EQ(ERR_IO_PENDING,
-              two_transaction.Start(GetRequestInfo("two.html"),
+              two_transaction.Start(GetRequestInfo("two.html", options),
                                     two_callback.callback(), BoundNetLog()));
 
     HttpNetworkTransaction three_transaction(session_.get());
     TestCompletionCallback three_callback;
     EXPECT_EQ(ERR_IO_PENDING,
-              three_transaction.Start(GetRequestInfo("three.html"),
+              three_transaction.Start(GetRequestInfo("three.html", options),
                                       three_callback.callback(),
                                       BoundNetLog()));
 
     HttpNetworkTransaction four_transaction(session_.get());
     TestCompletionCallback four_callback;
     EXPECT_EQ(ERR_IO_PENDING,
-              four_transaction.Start(GetRequestInfo("four.html"),
+              four_transaction.Start(GetRequestInfo("four.html", options),
                                      four_callback.callback(), BoundNetLog()));
 
     ExpectResponse("one.html", *one_transaction.get(), SYNCHRONOUS);
     EXPECT_EQ(OK, two_callback.WaitForResult());
     ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
     EXPECT_EQ(OK, three_callback.WaitForResult());
     ExpectResponse("three.html", three_transaction, SYNCHRONOUS);
 
     one_transaction.reset();
     EXPECT_EQ(OK, four_callback.WaitForResult());
@@ skipping 94 matching lines @@
     MockRead(SYNCHRONOUS, 8, "two.html"),
     MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
     MockRead(SYNCHRONOUS, 11, "three.html"),
     MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
     MockRead(SYNCHRONOUS, 15, "four.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
-  CompleteFourRequests();
+  CompleteFourRequests(REQUEST_DEFAULT);
 
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
+}
+
+TEST_F(HttpPipelinedNetworkTransactionTest, WontPipelineMainResource) {
+  int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL);
+  ClientSocketPoolManager::set_max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+  Initialize(false);
+
+  MockWrite writes[] = {
+    MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
+              "Host: localhost\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
+              "Host: localhost\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 8, "GET /three.html HTTP/1.1\r\n"
+              "Host: localhost\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 12, "GET /four.html HTTP/1.1\r\n"
+              "Host: localhost\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+  };
+  MockRead reads[] = {
+    MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 3, "one.html"),
+    MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 7, "two.html"),
+    MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 11, "three.html"),
+    MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
+    MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
+    MockRead(SYNCHRONOUS, 15, "four.html"),
+  };
+  AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
+
+  CompleteFourRequests(REQUEST_MAIN_RESOURCE);
+
+  ClientSocketPoolManager::set_max_sockets_per_group(
+      HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, UnknownSizeEvictsToNewPipeline) {
   Initialize(false);
 
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
@@ skipping 329 matching lines @@
     MockRead(SYNCHRONOUS, 15, "four.html"),
     MockRead(ASYNC, 18, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 19, "Content-Length: 24\r\n\r\n"),
     MockRead(SYNCHRONOUS, 20, "second-pipeline-one.html"),
     MockRead(SYNCHRONOUS, 21, "HTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, 22, "Content-Length: 24\r\n\r\n"),
     MockRead(SYNCHRONOUS, 23, "second-pipeline-two.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
-  CompleteFourRequests();
+  CompleteFourRequests(REQUEST_DEFAULT);
 
   HttpNetworkTransaction second_one_transaction(session_.get());
   TestCompletionCallback second_one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             second_one_transaction.Start(
                 GetRequestInfo("second-pipeline-one.html"),
                 second_one_callback.callback(), BoundNetLog()));
   MessageLoop::current()->RunAllPending();
 
   HttpNetworkTransaction second_two_transaction(session_.get());
@@ skipping 299 matching lines @@
   EXPECT_EQ(ERR_PIPELINE_EVICTION, two_callback.WaitForResult());
   two_transaction.reset();
   EXPECT_EQ(ERR_PIPELINE_EVICTION, three_callback.WaitForResult());
   three_transaction.reset();
   EXPECT_EQ(ERR_PIPELINE_EVICTION, four_callback.WaitForResult());
 }
 
 }  // anonymous namespace
 
 }  // namespace net