Modify SpdyHeaderBlock's internals to consolidate header values only on first access.

net/spdy/spdy_header_block_test.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/spdy/spdy_header_block.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/values.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::StringPiece;
 using std::make_pair;
 using std::string;
+using std::vector;

[Ryan Hamilton, 2017/01/10 22:46:12]

nit: IIRC, the internal code has been modified to use the std:: in front of most
things. We recently landed a cleanup to QUIC shared code to remove these usings.
Not something for this CL, but something to think about.

[Bence, 2017/01/11 14:25:13]

This is definitely worth exploring.  For the time being though, it seems that
vector does not have std:: in front in this particular file in the internal
code.

 using ::testing::ElementsAre;
 
 namespace net {
 namespace test {
 
 class ValueProxyPeer {
  public:
-  static base::StringPiece key(SpdyHeaderBlock::ValueProxy* p) {
-    return p->key_;
-  }
+  static StringPiece key(SpdyHeaderBlock::ValueProxy* p) { return p->key_; }
 };
 
-std::pair<base::StringPiece, base::StringPiece> Pair(base::StringPiece k,
-                                                     base::StringPiece v) {
+std::pair<StringPiece, StringPiece> Pair(StringPiece k, StringPiece v) {
   return make_pair(k, v);
 }
 
 // This test verifies that SpdyHeaderBlock behaves correctly when empty.
 TEST(SpdyHeaderBlockTest, EmptyBlock) {
   SpdyHeaderBlock block;
   EXPECT_TRUE(block.empty());
   EXPECT_EQ(0u, block.size());
   EXPECT_EQ(block.end(), block.find("foo"));
   EXPECT_TRUE(block.end() == block.begin());
 
   // Should have no effect.
   block.erase("bar");
 }
 
 TEST(SpdyHeaderBlockTest, KeyMemoryReclaimedOnLookup) {
   SpdyHeaderBlock block;
-  base::StringPiece copied_key1;
+  StringPiece copied_key1;
   {
     auto proxy1 = block["some key name"];
     copied_key1 = ValueProxyPeer::key(&proxy1);
   }
-  base::StringPiece copied_key2;
+  StringPiece copied_key2;
   {
     auto proxy2 = block["some other key name"];
     copied_key2 = ValueProxyPeer::key(&proxy2);
   }
   // Because proxy1 was never used to modify the block, the memory used for the
   // key could be reclaimed and used for the second call to operator[].
   // Therefore, we expect the pointers of the two StringPieces to be equal.
   EXPECT_EQ(copied_key1.data(), copied_key2.data());
 
   {
@@ skipping 115 matching lines @@
 
   block.AppendValueOrAddHeader("h3", "h3v2");
   block.AppendValueOrAddHeader("h2", "h2v2");
   block.AppendValueOrAddHeader("h1", "h1v2");
   block.AppendValueOrAddHeader("cookie", "key2=value2");
 
   block.AppendValueOrAddHeader("cookie", "key3=value3");
   block.AppendValueOrAddHeader("h1", "h1v3");
   block.AppendValueOrAddHeader("h2", "h2v3");
   block.AppendValueOrAddHeader("h3", "h3v3");
+  block.AppendValueOrAddHeader("h4", "singleton");
 
   EXPECT_EQ("key1=value1; key2=value2; key3=value3", block["cookie"]);
   EXPECT_EQ("baz", block["foo"]);
   EXPECT_EQ(string("h1v1\0h1v2\0h1v3", 14), block["h1"]);
   EXPECT_EQ(string("h2v1\0h2v2\0h2v3", 14), block["h2"]);
   EXPECT_EQ(string("h3v2\0h3v3", 9), block["h3"]);
+  EXPECT_EQ("singleton", block["h4"]);
+}
+
+TEST(JoinTest, JoinEmpty) {
+  vector<StringPiece> empty;
+  StringPiece separator = ", ";
+  char buf[10] = "";
+  size_t written = Join(buf, empty, separator);
+  EXPECT_EQ(0u, written);
+}
+
+TEST(JoinTest, JoinOne) {
+  vector<StringPiece> v = {"one"};
+  StringPiece separator = ", ";
+  char buf[15];
+  size_t written = Join(buf, v, separator);
+  EXPECT_EQ(3u, written);
+  EXPECT_EQ("one", StringPiece(buf, written));
+}
+
+TEST(JoinTest, JoinMultiple) {
+  vector<StringPiece> v = {"one", "two", "three"};
+  StringPiece separator = ", ";
+  char buf[15];
+  size_t written = Join(buf, v, separator);
+  EXPECT_EQ(15u, written);
+  EXPECT_EQ("one, two, three", StringPiece(buf, written));
 }
 
 }  // namespace test
 }  // namespace net