Clang format slam.

net/spdy/hpack_huffman_aggregator_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_huffman_aggregator.h"
 
 #include "base/metrics/histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
@@ skipping 12 matching lines @@
 const char kHistogramName[] = "Net.SpdyHpackEncodedCharacterFrequency";
 }  // namespace
 
 namespace test {
 
 class HpackHuffmanAggregatorPeer {
  public:
   explicit HpackHuffmanAggregatorPeer(HpackHuffmanAggregator* agg)
       : agg_(agg) {}
 
-  std::vector<size_t>* counts() {
-    return &agg_->counts_;
-  }
+  std::vector<size_t>* counts() { return &agg_->counts_; }
   HpackHuffmanAggregator::OriginEncoders* encoders() {
     return &agg_->encoders_;
   }
-  size_t total_counts() {
-    return agg_->total_counts_;
-  }
+  size_t total_counts() { return agg_->total_counts_; }
   void set_total_counts(size_t total_counts) {
     agg_->total_counts_ = total_counts;
   }
   void set_max_encoders(size_t max_encoders) {
     agg_->max_encoders_ = max_encoders;
   }
   static bool IsCrossOrigin(const HttpRequestInfo& request) {
     return HpackHuffmanAggregator::IsCrossOrigin(request);
   }
   static void CreateSpdyHeadersFromHttpResponse(
       const HttpResponseHeaders& headers,
       SpdyHeaderBlock* headers_out) {
-    HpackHuffmanAggregator::CreateSpdyHeadersFromHttpResponse(
-        headers, headers_out);
+    HpackHuffmanAggregator::CreateSpdyHeadersFromHttpResponse(headers,
+                                                              headers_out);
   }
   HpackEncoder* ObtainEncoder(const SpdySessionKey& key) {
     return agg_->ObtainEncoder(key);
   }
-  void PublishCounts() {
-    agg_->PublishCounts();
-  }
+  void PublishCounts() { agg_->PublishCounts(); }
 
  private:
   HpackHuffmanAggregator* agg_;
 };
 
 }  // namespace test
 
 class HpackHuffmanAggregatorTest : public ::testing::Test {
  protected:
-  HpackHuffmanAggregatorTest()
-      : peer_(&agg_) {}
+  HpackHuffmanAggregatorTest() : peer_(&agg_) {}
 
   HpackHuffmanAggregator agg_;
   test::HpackHuffmanAggregatorPeer peer_;
 };
 
 TEST_F(HpackHuffmanAggregatorTest, CrossOriginDetermination) {
   HttpRequestInfo request;
   request.url = GURL("https://www.foo.com/a/page");
 
   // Main load without referer.
@@ skipping 21 matching lines @@
 
   // Non-main load with same referer host but different schemes.
   request.extra_headers.SetHeader(HttpRequestHeaders::kReferer,
                                   "http://www.foo.com/other/page");
   EXPECT_TRUE(peer_.IsCrossOrigin(request));
 }
 
 TEST_F(HpackHuffmanAggregatorTest, EncoderLRUQueue) {
   peer_.set_max_encoders(2);
 
-  SpdySessionKey key1(HostPortPair("one.com", 443), ProxyServer::Direct(),
+  SpdySessionKey key1(HostPortPair("one.com", 443),
+                      ProxyServer::Direct(),
                       PRIVACY_MODE_ENABLED);
-  SpdySessionKey key2(HostPortPair("two.com", 443), ProxyServer::Direct(),
+  SpdySessionKey key2(HostPortPair("two.com", 443),
+                      ProxyServer::Direct(),
                       PRIVACY_MODE_ENABLED);
-  SpdySessionKey key3(HostPortPair("three.com", 443), ProxyServer::Direct(),
+  SpdySessionKey key3(HostPortPair("three.com", 443),
+                      ProxyServer::Direct(),
                       PRIVACY_MODE_ENABLED);
 
   // Creates one.com.
   HpackEncoder* one = peer_.ObtainEncoder(key1);
   EXPECT_EQ(1u, peer_.encoders()->size());
 
   // Creates two.com. No evictions.
   HpackEncoder* two = peer_.ObtainEncoder(key2);
   EXPECT_EQ(2u, peer_.encoders()->size());
   EXPECT_NE(one, two);
@@ skipping 16 matching lines @@
 
   peer_.PublishCounts();
 
   // Internal counts were reset after being published.
   EXPECT_THAT(*peer_.counts(), Each(Eq(0u)));
   EXPECT_EQ(0u, peer_.total_counts());
 
   // Verify histogram counts match the expectation.
   scoped_ptr<base::HistogramSamples> samples =
       base::StatisticsRecorder::FindHistogram(kHistogramName)
-      ->SnapshotSamples();
+          ->SnapshotSamples();
 
   EXPECT_EQ(0, samples->GetCount(0));
   EXPECT_EQ(1, samples->GetCount(1));
   EXPECT_EQ(101, samples->GetCount(129));
   EXPECT_EQ(10, samples->GetCount(256));
   EXPECT_EQ(112, samples->TotalCount());
 
   // Publish a second round of counts;
   (*peer_.counts())[1] = 32;
   (*peer_.counts())[128] = 5;
   peer_.set_total_counts(37);
 
   peer_.PublishCounts();
 
   // Verify they've been aggregated into the previous counts.
   samples = base::StatisticsRecorder::FindHistogram(kHistogramName)
-      ->SnapshotSamples();
+                ->SnapshotSamples();
 
   EXPECT_EQ(0, samples->GetCount(0));
   EXPECT_EQ(1, samples->GetCount(1));
   EXPECT_EQ(32, samples->GetCount(2));
   EXPECT_EQ(106, samples->GetCount(129));
   EXPECT_EQ(10, samples->GetCount(256));
   EXPECT_EQ(149, samples->TotalCount());
 }
 
 TEST_F(HpackHuffmanAggregatorTest, CreateSpdyResponseHeaders) {
   char kRawHeaders[] =
-    "HTTP/1.1    202   Accepted  \0"
-    "Content-TYPE  : text/html; charset=utf-8  \0"
-    "Set-Cookie: foo=bar \0"
-    "Set-Cookie:   baz=bing \0"
-    "Cache-Control: pragma=no-cache \0"
-    "Cache-CONTROL: expires=12345 \0\0";
+      "HTTP/1.1    202   Accepted  \0"
+      "Content-TYPE  : text/html; charset=utf-8  \0"
+      "Set-Cookie: foo=bar \0"
+      "Set-Cookie:   baz=bing \0"
+      "Cache-Control: pragma=no-cache \0"
+      "Cache-CONTROL: expires=12345 \0\0";
 
   scoped_refptr<HttpResponseHeaders> parsed_headers(new HttpResponseHeaders(
       std::string(kRawHeaders, arraysize(kRawHeaders) - 1)));
 
   SpdyHeaderBlock headers;
   peer_.CreateSpdyHeadersFromHttpResponse(*parsed_headers, &headers);
-  EXPECT_THAT(headers, ElementsAre(
-      Pair(":status", "202"),
-      Pair("cache-control", std::string("pragma=no-cache\0expires=12345", 29)),
-      Pair("content-type", "text/html; charset=utf-8"),
-      Pair("set-cookie", std::string("foo=bar\0baz=bing", 16))));
+  EXPECT_THAT(
+      headers,
+      ElementsAre(Pair(":status", "202"),
+                  Pair("cache-control",
+                       std::string("pragma=no-cache\0expires=12345", 29)),
+                  Pair("content-type", "text/html; charset=utf-8"),
+                  Pair("set-cookie", std::string("foo=bar\0baz=bing", 16))));
 }
 
 }  // namespace net