Revert "Only allow HTTP/0.9 support on default ports."

net/http/http_stream_parser_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 "net/http/http_stream_parser.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 1052 matching lines @@
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)) -
                 static_cast<int64_t>(strlen("a fake websocket frame")),
             parser.received_bytes());
 }
 
 // Helper class for constructing HttpStreamParser and running GET requests.
 class SimpleGetRunner {
  public:
-  SimpleGetRunner()
-      : url_("http://localhost"),
-        http_09_on_non_default_ports_enabled_(false),
-        read_buffer_(new GrowableIOBuffer),
-        sequence_number_(0) {
+  SimpleGetRunner() : read_buffer_(new GrowableIOBuffer), sequence_number_(0) {
     writes_.push_back(MockWrite(
         SYNCHRONOUS, sequence_number_++, "GET / HTTP/1.1\r\n\r\n"));
   }
 
-  void set_url(const GURL& url) { url_ = url; }
-  void set_http_09_on_non_default_ports_enabled(
-      bool http_09_on_non_default_ports_enabled) {
-    http_09_on_non_default_ports_enabled_ =
-        http_09_on_non_default_ports_enabled;
-  }
-
   HttpStreamParser* parser() { return parser_.get(); }
   GrowableIOBuffer* read_buffer() { return read_buffer_.get(); }
   HttpResponseInfo* response_info() { return &response_info_; }
 
   void AddInitialData(const std::string& data) {
     int offset = read_buffer_->offset();
     int size = data.size();
     read_buffer_->SetCapacity(offset + size);
     memcpy(read_buffer_->StartOfBuffer() + offset, data.data(), size);
     read_buffer_->set_offset(offset + size);
   }
 
   void AddRead(const std::string& data) {
     reads_.push_back(MockRead(SYNCHRONOUS, sequence_number_++, data.data()));
   }
 
   void SetupParserAndSendRequest() {
     reads_.push_back(MockRead(SYNCHRONOUS, 0, sequence_number_++));  // EOF
 
     data_.reset(new SequencedSocketData(&reads_.front(), reads_.size(),
                                         &writes_.front(), writes_.size()));
     socket_handle_ = CreateConnectedSocketHandle(data_.get());
 
     request_info_.method = "GET";
-    request_info_.url = url_;
+    request_info_.url = GURL("http://localhost");
     request_info_.load_flags = LOAD_NORMAL;
 
     parser_.reset(new HttpStreamParser(
         socket_handle_.get(), &request_info_, read_buffer(), BoundNetLog()));
 
-    parser_->set_http_09_on_non_default_ports_enabled(
-        http_09_on_non_default_ports_enabled_);
-
     TestCompletionCallback callback;
     ASSERT_EQ(OK, parser_->SendRequest("GET / HTTP/1.1\r\n", request_headers_,
                                        &response_info_, callback.callback()));
   }
 
-  void ReadHeadersExpectingError(Error error) {
+  void ReadHeaders() {
     TestCompletionCallback callback;
-    EXPECT_THAT(parser_->ReadResponseHeaders(callback.callback()),
-                IsError(error));
+    EXPECT_THAT(parser_->ReadResponseHeaders(callback.callback()), IsOk());
   }
 
-  void ReadHeaders() { ReadHeadersExpectingError(OK); }
-
   void ReadBody(int user_buf_len, int* read_lengths) {
     TestCompletionCallback callback;
     scoped_refptr<IOBuffer> buffer = new IOBuffer(user_buf_len);
     int rv;
     int i = 0;
     while (true) {
       rv = parser_->ReadResponseBody(
           buffer.get(), user_buf_len, callback.callback());
       EXPECT_EQ(read_lengths[i], rv);
       i++;
       if (rv <= 0)
         return;
     }
   }
 
  private:
-  GURL url_;
-  bool http_09_on_non_default_ports_enabled_;
-
   HttpRequestHeaders request_headers_;
   HttpResponseInfo response_info_;
   HttpRequestInfo request_info_;
   scoped_refptr<GrowableIOBuffer> read_buffer_;
   std::vector<MockRead> reads_;
   std::vector<MockWrite> writes_;
   std::unique_ptr<ClientSocketHandle> socket_handle_;
   std::unique_ptr<SequencedSocketData> data_;
   std::unique_ptr<HttpStreamParser> parser_;
   int sequence_number_;
 };
 
-// Test that HTTP/0.9 works as expected, only on ports where it should be
-// enabled.
-TEST(HttpStreamParser, Http09PortTests) {
-  struct TestCase {
-    const char* url;
-    bool http_09_on_non_default_ports_enabled;
+// Test that HTTP/0.9 response size is correctly calculated.
+TEST(HttpStreamParser, ReceivedBytesNoHeaders) {
+  std::string response = "hello\r\nworld\r\n";
 
-    // Expected result when trying to read headers.
-    Error expected_header_error;
-  };
-
-  const TestCase kTestCases[] = {
-      // Default ports should work for HTTP/0.9, regardless of whether the port
-      // is explicitly specified or not.
-      {"http://foo.com/", false, OK},
-      {"http://foo.com:80/", false, OK},
-      {"https://foo.com/", false, OK},
-      {"https://foo.com:443/", false, OK},
-
-      // Non-standard ports should not support HTTP/0.9, by default.
-      {"http://foo.com:8080/", false, ERR_INVALID_HTTP_RESPONSE},
-      {"https://foo.com:8080/", false, ERR_INVALID_HTTP_RESPONSE},
-      {"http://foo.com:443/", false, ERR_INVALID_HTTP_RESPONSE},
-      {"https://foo.com:80/", false, ERR_INVALID_HTTP_RESPONSE},
-
-      // Allowing non-default ports should not break the default ones.
-      {"http://foo.com/", true, OK},
-      {"http://foo.com:80/", true, OK},
-      {"https://foo.com/", true, OK},
-      {"https://foo.com:443/", true, OK},
-
-      // Check that non-default ports works.
-      {"http://foo.com:8080/", true, OK},
-      {"https://foo.com:8080/", true, OK},
-      {"http://foo.com:443/", true, OK},
-      {"https://foo.com:80/", true, OK},
-  };
-
-  std::string response = "hello\r\nworld\r\n";
+  SimpleGetRunner get_runner;
+  get_runner.AddRead(response);
+  get_runner.SetupParserAndSendRequest();
+  get_runner.ReadHeaders();
+  EXPECT_EQ(0, get_runner.parser()->received_bytes());
   int response_size = response.size();
-
-  for (const auto& test_case : kTestCases) {
-    SimpleGetRunner get_runner;
-    get_runner.set_url(GURL(test_case.url));
-    get_runner.set_http_09_on_non_default_ports_enabled(
-        test_case.http_09_on_non_default_ports_enabled);
-    get_runner.AddRead(response);
-    get_runner.SetupParserAndSendRequest();
-
-    get_runner.ReadHeadersExpectingError(test_case.expected_header_error);
-    if (test_case.expected_header_error != OK)
-      continue;
-
-    ASSERT_TRUE(get_runner.response_info()->headers);
-    EXPECT_EQ("HTTP/0.9 200 OK",
-              get_runner.response_info()->headers->GetStatusLine());
-
-    EXPECT_EQ(0, get_runner.parser()->received_bytes());
-    int read_lengths[] = {response_size, 0};
-    get_runner.ReadBody(response_size, read_lengths);
-    EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
-    EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP0_9,
-              get_runner.response_info()->connection_info);
-  }
-}
-
-// Make sure that HTTP/0.9 isn't allowed in the truncated header case on a weird
-// port.
-TEST(HttpStreamParser, Http09TruncatedHeaderPortTest) {
-  SimpleGetRunner get_runner;
-  get_runner.set_url(GURL("http://foo.com:8080/"));
-  get_runner.AddRead("HT");
-  get_runner.SetupParserAndSendRequest();
-
-  get_runner.ReadHeadersExpectingError(ERR_INVALID_HTTP_RESPONSE);
+  int read_lengths[] = {response_size, 0};
+  get_runner.ReadBody(response_size, read_lengths);
+  EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
+  EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP0_9,
+            get_runner.response_info()->connection_info);
 }
 
 // Test basic case where there is no keep-alive or extra data from the socket,
 // and the entire response is received in a single read.
 TEST(HttpStreamParser, ReceivedBytesNormal) {
   std::string headers =
       "HTTP/1.0 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
   std::string body = "content";
   std::string response = headers + body;
@@ skipping 253 matching lines @@
   ASSERT_EQ(kBodySize, parser.ReadResponseBody(
       body_buffer.get(), kBodySize, callback.callback()));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
 }
 
 }  // namespace
 
 }  // namespace net