| // 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" |
| #include "net/http/http_response_headers.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace net { |
| |
| using ::testing::Each; |
| using ::testing::ElementsAre; |
| using ::testing::Eq; |
| using ::testing::Pair; |
| |
| namespace { |
| 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_; |
| } |
| HpackHuffmanAggregator::OriginEncoders* encoders() { |
| return &agg_->encoders_; |
| } |
| 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); |
| } |
| HpackEncoder* ObtainEncoder(const SpdySessionKey& key) { |
| return agg_->ObtainEncoder(key); |
| } |
| void PublishCounts() { |
| agg_->PublishCounts(); |
| } |
| |
| private: |
| HpackHuffmanAggregator* agg_; |
| }; |
| |
| } // namespace test |
| |
| class HpackHuffmanAggregatorTest : public ::testing::Test { |
| protected: |
| 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. |
| request.load_flags = LOAD_MAIN_FRAME; |
| EXPECT_FALSE(peer_.IsCrossOrigin(request)); |
| |
| // Non-main load without referer. Treated as cross-origin. |
| request.load_flags = 0; |
| EXPECT_TRUE(peer_.IsCrossOrigin(request)); |
| |
| // Main load with different referer origin. |
| request.load_flags = LOAD_MAIN_FRAME; |
| request.extra_headers.SetHeader(HttpRequestHeaders::kReferer, |
| "https://www.bar.com/other/page"); |
| EXPECT_FALSE(peer_.IsCrossOrigin(request)); |
| |
| // Non-main load with different referer orign. |
| request.load_flags = 0; |
| EXPECT_TRUE(peer_.IsCrossOrigin(request)); |
| |
| // Non-main load with same referer orign. |
| request.extra_headers.SetHeader(HttpRequestHeaders::kReferer, |
| "https://www.foo.com/other/page"); |
| EXPECT_FALSE(peer_.IsCrossOrigin(request)); |
| |
| // 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(), |
| PRIVACY_MODE_ENABLED); |
| SpdySessionKey key2(HostPortPair("two.com", 443), ProxyServer::Direct(), |
| PRIVACY_MODE_ENABLED); |
| 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); |
| |
| // Touch one.com. |
| EXPECT_EQ(one, peer_.ObtainEncoder(key1)); |
| |
| // Creates three.com. Evicts two.com, as it's least-recently used. |
| HpackEncoder* three = peer_.ObtainEncoder(key3); |
| EXPECT_EQ(one, peer_.ObtainEncoder(key1)); |
| EXPECT_NE(one, three); |
| EXPECT_EQ(2u, peer_.encoders()->size()); |
| } |
| |
| TEST_F(HpackHuffmanAggregatorTest, PublishCounts) { |
| (*peer_.counts())[0] = 1; |
| (*peer_.counts())[255] = 10; |
| (*peer_.counts())[128] = 101; |
| peer_.set_total_counts(112); |
| |
| 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(); |
| |
| 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(); |
| |
| 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"; |
| |
| 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)))); |
| } |
| |
| } // namespace net |