Clang format slam.

net/spdy/hpack_encoder_test.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/spdy/hpack_encoder.h"
 
 #include <map>
 #include <string>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 using base::StringPiece;
 using std::string;
 using testing::ElementsAre;
 
 namespace test {
 
 class HpackHeaderTablePeer {
  public:
-  explicit HpackHeaderTablePeer(HpackHeaderTable* table)
-      : table_(table) {}
+  explicit HpackHeaderTablePeer(HpackHeaderTable* table) : table_(table) {}
 
   HpackHeaderTable::EntryTable* dynamic_entries() {
     return &table_->dynamic_entries_;
   }
 
  private:
   HpackHeaderTable* table_;
 };
 
 class HpackEncoderPeer {
  public:
   typedef HpackEncoder::Representation Representation;
   typedef HpackEncoder::Representations Representations;
 
-  explicit HpackEncoderPeer(HpackEncoder* encoder)
-    : encoder_(encoder) {}
+  explicit HpackEncoderPeer(HpackEncoder* encoder) : encoder_(encoder) {}
 
-  HpackHeaderTable* table() {
-    return &encoder_->header_table_;
-  }
-  HpackHeaderTablePeer table_peer() {
-    return HpackHeaderTablePeer(table());
-  }
+  HpackHeaderTable* table() { return &encoder_->header_table_; }
+  HpackHeaderTablePeer table_peer() { return HpackHeaderTablePeer(table()); }
   bool allow_huffman_compression() {
     return encoder_->allow_huffman_compression_;
   }
   void set_allow_huffman_compression(bool allow) {
     encoder_->allow_huffman_compression_ = allow;
   }
-  void EmitString(StringPiece str) {
-    encoder_->EmitString(str);
-  }
-  void TakeString(string* out) {
-    encoder_->output_stream_.TakeString(out);
-  }
+  void EmitString(StringPiece str) { encoder_->EmitString(str); }
+  void TakeString(string* out) { encoder_->output_stream_.TakeString(out); }
   void UpdateCharacterCounts(StringPiece str) {
     encoder_->UpdateCharacterCounts(str);
   }
   static void CookieToCrumbs(StringPiece cookie,
                              std::vector<StringPiece>* out) {
     Representations tmp;
     HpackEncoder::CookieToCrumbs(make_pair("", cookie), &tmp);
 
     out->clear();
     for (size_t i = 0; i != tmp.size(); ++i) {
       out->push_back(tmp[i].second);
     }
   }
 
  private:
   HpackEncoder* encoder_;
 };
 
 }  // namespace test
 
 namespace {
 
 using std::map;
 using testing::ElementsAre;
 
 class HpackEncoderTest : public ::testing::Test {
  protected:
   typedef test::HpackEncoderPeer::Representations Representations;
 
-  HpackEncoderTest()
-      : encoder_(ObtainHpackHuffmanTable()),
-        peer_(&encoder_) {}
+  HpackEncoderTest() : encoder_(ObtainHpackHuffmanTable()), peer_(&encoder_) {}
 
   virtual void SetUp() {
     static_ = peer_.table()->GetByIndex(1);
     // Populate dynamic entries into the table fixture. For simplicity each
     // entry has name.size() + value.size() == 10.
     key_1_ = peer_.table()->TryAddEntry("key1", "value1");
     key_2_ = peer_.table()->TryAddEntry("key2", "value2");
     cookie_a_ = peer_.table()->TryAddEntry("cookie", "a=bb");
     cookie_c_ = peer_.table()->TryAddEntry("cookie", "c=dd");
 
@@ skipping 263 matching lines @@
   // |key_2_| & |cookie_c_| are toggled on.
   // |cookie_a_| is toggled off.
   // A new cookie entry is added.
   {
     map<string, string> headers;
     headers["key1"] = "value1";
     headers["key2"] = "value2";
     headers["cookie"] = "c=dd; e=ff";
 
     ExpectIndex(cookie_c_->Index());  // Toggle on.
-    ExpectIndex(key_1_->Index());  // Double-toggle before eviction.
+    ExpectIndex(key_1_->Index());     // Double-toggle before eviction.
     ExpectIndex(key_1_->Index());
     ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "e=ff");
     ExpectIndex(key_2_->Index() + 1);  // Toggle on. Add 1 to reflect insertion.
     ExpectIndex(cookie_a_->Index() + 1);  // Toggle off.
     CompareWithExpectedEncoding(headers);
   }
   // Pass 3: |key_2_| is evicted and implicitly toggled off.
   // |cookie_c_| is explicitly toggled off.
   // "key1" is re-inserted.
   {
@@ skipping 35 matching lines @@
 
   peer.CookieToCrumbs("foo;bar; baz;baz;bing;", &out);
   EXPECT_THAT(out, ElementsAre("", "bar", "baz", "bing", "foo"));
 }
 
 TEST_F(HpackEncoderTest, UpdateCharacterCounts) {
   std::vector<size_t> counts(256, 0);
   size_t total_counts = 0;
   encoder_.SetCharCountsStorage(&counts, &total_counts);
 
-  char kTestString[] = "foo\0\1\xff""boo";
+  char kTestString[] =
+      "foo\0\1\xff"
+      "boo";
   peer_.UpdateCharacterCounts(
       StringPiece(kTestString, arraysize(kTestString) - 1));
 
   std::vector<size_t> expect(256, 0);
   expect[static_cast<uint8>('f')] = 1;
   expect[static_cast<uint8>('o')] = 4;
   expect[static_cast<uint8>('\0')] = 1;
   expect[static_cast<uint8>('\1')] = 1;
   expect[static_cast<uint8>('\xff')] = 1;
   expect[static_cast<uint8>('b')] = 1;
 
   EXPECT_EQ(expect, counts);
   EXPECT_EQ(9u, total_counts);
 }
 
 }  // namespace
 
 }  // namespace net