Replace StreamListenSocket with StreamSocket in HttpServer.

net/server/http_connection_unittest.cc

+// Copyright 2014 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/server/http_connection.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace {
+
+class HttpConnectionTest : public testing::Test {

[mmenke, 2014/08/14 16:36:02]

This test fixture doesn't really get us anything, can just get rid of it, and
move the functions up into the anonymous namespace.  Then just replace TEST_F
with TEST.

[byungchul, 2014/08/14 18:44:03]

Done.

+ public:
+  static void CheckCapacity(scoped_refptr<HttpConnection::ReadIOBuffer> buffer,

[mmenke, 2014/08/14 16:36:02]

include ref_counted

[byungchul, 2014/08/14 18:44:02]

Done.

+                            int expected_capacity) {
+    EXPECT_EQ(expected_capacity, buffer->GetCapacity());
+    EXPECT_EQ(expected_capacity, buffer->RemainingCapacity());
+  }
+
+  static std::string GetTestString(int size) {

[mmenke, 2014/08/14 16:36:02]

include <string>

[byungchul, 2014/08/14 18:44:02]

Done.

+    std::string test_string;
+    for (int i = 0; i < size; ++i) {
+      test_string.push_back('A' + (i % 26));
+    }
+    return test_string;
+  }
+};
+
+TEST_F(HttpConnectionTest, ReadIOBuffer_SetCapacity) {
+  scoped_refptr<HttpConnection::ReadIOBuffer> buffer(
+      new HttpConnection::ReadIOBuffer);
+  CheckCapacity(buffer, HttpConnection::ReadIOBuffer::kInitialBufSize);
+  EXPECT_EQ(0, buffer->GetSize());
+
+  const int kNewCapacity = HttpConnection::ReadIOBuffer::kInitialBufSize + 128;
+  buffer->SetCapacity(kNewCapacity);
+  CheckCapacity(buffer, kNewCapacity);
+  EXPECT_EQ(0, buffer->GetSize());

[mmenke, 2014/08/14 16:36:02]

Should we write kInitialBufSize bytes to the buffer, and make sure they're still
there after we update capacity?  And then write 128 bytes to the end, to make
sure the capacity was really updated?

[byungchul, 2014/08/14 18:44:03]

Done.

+}
+
+TEST_F(HttpConnectionTest, ReadIOBuffer_IncreaseCapacity) {
+  scoped_refptr<HttpConnection::ReadIOBuffer> buffer(
+      new HttpConnection::ReadIOBuffer);
+  EXPECT_TRUE(buffer->IncreaseCapacity());
+  CheckCapacity(buffer,
+                HttpConnection::ReadIOBuffer::kInitialBufSize
+                    * HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor);
+  EXPECT_EQ(0, buffer->GetSize());
+
+  // Increase capacity until it fails.
+  while (buffer->IncreaseCapacity());
+  EXPECT_FALSE(buffer->IncreaseCapacity());
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0,
+            buffer->max_buffer_size());
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize + 0,
+            buffer->GetCapacity());
+
+  // Enlarge capacity limit.
+  buffer->set_max_buffer_size(buffer->max_buffer_size() * 2);
+  EXPECT_TRUE(buffer->IncreaseCapacity());
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize
+                * HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor,
+            buffer->GetCapacity());
+
+  // Shrink capacity limit. It doesn't change capacity itself.
+  buffer->set_max_buffer_size(
+      HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize / 2);
+  EXPECT_FALSE(buffer->IncreaseCapacity());
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kDefaultMaxBufferSize
+                * HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor,
+            buffer->GetCapacity());

[mmenke, 2014/08/14 16:36:02]

Same goes for this - should we make sure that we keep the old bytes?

[byungchul, 2014/08/14 18:44:02]

Done.

+}
+
+TEST_F(HttpConnectionTest, ReadIOBuffer_DidRead_DidConsume) {
+  scoped_refptr<HttpConnection::ReadIOBuffer> buffer(
+      new HttpConnection::ReadIOBuffer);
+  const char* start_of_buffer = buffer->StartOfBuffer();
+  EXPECT_EQ(start_of_buffer, buffer->data());
+
+  // Read data.
+  const int kReadLength = 128;
+  const std::string kReadData(GetTestString(kReadLength));
+  memcpy(buffer->data(), kReadData.data(), kReadLength);
+  buffer->DidRead(kReadLength);
+  // No change in total capacity.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize + 0,
+            buffer->GetCapacity());
+  // Change in unused capacity because of read data.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize - kReadLength,
+            buffer->RemainingCapacity());
+  EXPECT_EQ(kReadLength, buffer->GetSize());
+  // No change in start pointers of read data.
+  EXPECT_EQ(start_of_buffer, buffer->StartOfBuffer());
+  // Change in start pointer of unused buffer.
+  EXPECT_EQ(start_of_buffer + kReadLength, buffer->data());
+  // Test read data.
+  EXPECT_EQ(kReadData, std::string(buffer->StartOfBuffer(), buffer->GetSize()));
+
+  // Consume data partially.
+  const int kConsumedLength = 32;
+  ASSERT_LT(kConsumedLength, kReadLength);
+  buffer->DidConsume(kConsumedLength);
+  // Capacity reduced because read data was too small comparing to capacity.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor,
+            buffer->GetCapacity());
+  // Change in unused capacity because of read data.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor
+                - kReadLength + kConsumedLength,

[mmenke, 2014/08/14 16:36:02]

Put binary operators on previous line (Goes for this entire file)

[byungchul, 2014/08/14 18:44:03]

Done. I knew the style but it was more readable for me.

+            buffer->RemainingCapacity());
+  // Change in read size.
+  EXPECT_EQ(kReadLength - kConsumedLength, buffer->GetSize());
+  // Start data could be changed even when capacity is reduced.
+  start_of_buffer = buffer->StartOfBuffer();
+  // Change in start pointer of unused buffer.
+  EXPECT_EQ(start_of_buffer + kReadLength - kConsumedLength, buffer->data());
+  // Change in read data.
+  EXPECT_EQ(kReadData.substr(kConsumedLength),
+            std::string(buffer->StartOfBuffer(), buffer->GetSize()));
+
+  // Read more data.
+  const int kReadLength2 = 64;
+  buffer->DidRead(kReadLength2);
+  // No change in total capacity.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor,
+            buffer->GetCapacity());
+  // Change in unused capacity because of read data.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor
+                - kReadLength + kConsumedLength - kReadLength2,
+            buffer->RemainingCapacity());
+  // Change in read size
+  EXPECT_EQ(kReadLength - kConsumedLength + kReadLength2, buffer->GetSize());
+  // No change in start pointer of read part.
+  EXPECT_EQ(start_of_buffer, buffer->StartOfBuffer());
+  // Change in start pointer of unused buffer.
+  EXPECT_EQ(start_of_buffer + kReadLength - kConsumedLength + kReadLength2,
+            buffer->data());
+
+  // Consume data fully.
+  buffer->DidConsume(kReadLength - kConsumedLength + kReadLength2);
+  // Capacity reduced again because read data was too small.
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor,
+            buffer->GetCapacity());
+  EXPECT_EQ(HttpConnection::ReadIOBuffer::kInitialBufSize
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor
+                / HttpConnection::ReadIOBuffer::kCapacityIncreaseFactor,
+            buffer->RemainingCapacity());
+  // All reverts to initial because no data is left.
+  EXPECT_EQ(0, buffer->GetSize());
+  // Start data could be changed even when capacity is reduced.
+  start_of_buffer = buffer->StartOfBuffer();
+  EXPECT_EQ(start_of_buffer, buffer->data());
+}
+
+TEST_F(HttpConnectionTest, PendingWriteIOBuffer_Append_DidConsume) {
+  scoped_refptr<HttpConnection::PendingWriteIOBuffer> buffer(
+      new HttpConnection::PendingWriteIOBuffer());
+  EXPECT_TRUE(buffer->IsEmpty());
+  EXPECT_EQ(0, buffer->GetSizeToWrite());
+  EXPECT_EQ(0, buffer->total_size());
+
+  const std::string kData("data to write");
+  EXPECT_TRUE(buffer->Append(kData));
+  EXPECT_FALSE(buffer->IsEmpty());
+  EXPECT_EQ(static_cast<int>(kData.size()), buffer->GetSizeToWrite());
+  EXPECT_EQ(static_cast<int>(kData.size()), buffer->total_size());
+
+  const std::string kData2("more data to write");
+  EXPECT_TRUE(buffer->Append(kData2));
+  EXPECT_FALSE(buffer->IsEmpty());
+  // No change in size to write.
+  EXPECT_EQ(static_cast<int>(kData.size()), buffer->GetSizeToWrite());
+  // Change in total size.
+  EXPECT_EQ(static_cast<int>(kData.size() + kData2.size()),
+            buffer->total_size());
+
+  // Consume data partially.
+  const int kConsumedLength = kData.length() - 1;
+  buffer->DidConsume(kConsumedLength);
+  EXPECT_FALSE(buffer->IsEmpty());
+  // Change in size to write.
+  EXPECT_EQ(static_cast<int>(kData.size()) - kConsumedLength,
+            buffer->GetSizeToWrite());
+  // Change in total size.
+  EXPECT_EQ(static_cast<int>(kData.size() + kData2.size()) - kConsumedLength,
+            buffer->total_size());

[mmenke, 2014/08/14 16:36:02]

Should have a partial read, with an EXPECT_EQ for the remaining unread data.

[byungchul, 2014/08/14 18:44:03]

Did you mean partial consumption on ReadIOBuffer? It is done in
ReadIOBuffer_DidRead_DidConsume test.

+
+  // Consume first data fully.
+  buffer->DidConsume(kData.size() - kConsumedLength);
+  EXPECT_FALSE(buffer->IsEmpty());
+  // Now, size to write is size of data added second.
+  EXPECT_EQ(static_cast<int>(kData2.size()), buffer->GetSizeToWrite());
+  // Change in total size.
+  EXPECT_EQ(static_cast<int>(kData2.size()), buffer->total_size());
+
+  // Consume second data fully.
+  buffer->DidConsume(kData2.size());
+  EXPECT_TRUE(buffer->IsEmpty());
+  EXPECT_EQ(0, buffer->GetSizeToWrite());
+  EXPECT_EQ(0, buffer->total_size());
+}
+
+TEST_F(HttpConnectionTest, PendingWriteIOBuffer_TotalSizeLimit) {
+  scoped_refptr<HttpConnection::PendingWriteIOBuffer> buffer(
+      new HttpConnection::PendingWriteIOBuffer());
+  EXPECT_EQ(HttpConnection::PendingWriteIOBuffer::kDefaultMaxBufferSize + 0,
+            buffer->max_buffer_size());
+
+  // Set total size limit very small.
+  buffer->set_max_buffer_size(10);
+
+  const int kDataLength = 4;
+  const std::string kData(kDataLength, 'd');
+  EXPECT_TRUE(buffer->Append(kData));
+  EXPECT_EQ(kDataLength, buffer->total_size());
+  EXPECT_TRUE(buffer->Append(kData));
+  EXPECT_EQ(kDataLength * 2, buffer->total_size());
+
+  // Cannot append more data because it exceeds the limit.
+  EXPECT_FALSE(buffer->Append(kData));
+  EXPECT_EQ(kDataLength * 2, buffer->total_size());
+
+  // Consume data partially.
+  const int kConsumedLength = 2;
+  buffer->DidConsume(kConsumedLength);
+  EXPECT_EQ(kDataLength * 2 - kConsumedLength, buffer->total_size());
+
+  // Can add more data.
+  EXPECT_TRUE(buffer->Append(kData));
+  EXPECT_EQ(kDataLength * 3 - kConsumedLength, buffer->total_size());
+
+  // Cannot append more data because it exceeds the limit.
+  EXPECT_FALSE(buffer->Append(kData));
+  EXPECT_EQ(kDataLength * 3 - kConsumedLength, buffer->total_size());
+
+  // Enlarge limit.
+  buffer->set_max_buffer_size(20);
+  // Can add more data.
+  EXPECT_TRUE(buffer->Append(kData));
+  EXPECT_EQ(kDataLength * 4 - kConsumedLength, buffer->total_size());
+}
+
+}  // namespace
+}  // namespace net