net/spdy/hpack_huffman_aggregator.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 #include "net/spdy/hpack_huffman_aggregator.h"
   5
   6 #include "base/metrics/bucket_ranges.h"
   7 #include "base/metrics/field_trial.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/metrics/sample_vector.h"
  10 #include "base/stl_util.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_util.h"
  13 #include "net/base/load_flags.h"
  14 #include "net/http/http_request_headers.h"
  15 #include "net/http/http_request_info.h"
  16 #include "net/http/http_response_headers.h"
  17 #include "net/spdy/hpack_encoder.h"
  18 #include "net/spdy/spdy_http_utils.h"
  19
  20 namespace net {
  21
  22 namespace {
  23
  24 const char kHistogramName[] = "Net.SpdyHpackEncodedCharacterFrequency";
  25
  26 const size_t kTotalCountsPublishThreshold = 50000;
  27
  28 // Each encoder uses the default dynamic table size of 4096 total bytes.
  29 const size_t kMaxEncoders = 20;
  30
  31 }  // namespace
  32
  33 HpackHuffmanAggregator::HpackHuffmanAggregator()
  34   : counts_(256, 0),
  35     total_counts_(0),
  36     max_encoders_(kMaxEncoders) {
  37 }
  38
  39 HpackHuffmanAggregator::~HpackHuffmanAggregator() {
  40   STLDeleteContainerPairSecondPointers(encoders_.begin(), encoders_.end());
  41   encoders_.clear();
  42 }
  43
  44 void HpackHuffmanAggregator::AggregateTransactionCharacterCounts(
  45     const HttpRequestInfo& request,
  46     const HttpRequestHeaders& request_headers,
  47     const ProxyServer& proxy,
  48     const HttpResponseHeaders& response_headers) {
  49   if (IsCrossOrigin(request)) {
  50     return;
  51   }
  52   HostPortPair endpoint = HostPortPair(request.url.HostNoBrackets(),
  53                                        request.url.EffectiveIntPort());
  54   HpackEncoder* encoder = ObtainEncoder(
  55       SpdySessionKey(endpoint, proxy, request.privacy_mode));
  56
  57   // Convert and encode the request and response header sets.
  58   {
  59     SpdyHeaderBlock headers;
  60     CreateSpdyHeadersFromHttpRequest(
  61         request, request_headers, SPDY4, false, &headers);
  62
  63     std::string tmp_out;
  64     encoder->EncodeHeaderSet(headers, &tmp_out);
  65   }
  66   {
  67     SpdyHeaderBlock headers;
  68     CreateSpdyHeadersFromHttpResponse(response_headers, &headers);
  69
  70     std::string tmp_out;
  71     encoder->EncodeHeaderSet(headers, &tmp_out);
  72   }
  73   if (total_counts_ >= kTotalCountsPublishThreshold) {
  74     PublishCounts();
  75   }
  76 }
  77
  78 // static
  79 bool HpackHuffmanAggregator::UseAggregator() {
  80   const std::string group_name =
  81       base::FieldTrialList::FindFullName("HpackHuffmanAggregator");
  82   if (group_name == "Enabled") {
  83     return true;
  84   }
  85   return false;
  86 }
  87
  88 // static
  89 void HpackHuffmanAggregator::CreateSpdyHeadersFromHttpResponse(
  90     const HttpResponseHeaders& headers,
  91     SpdyHeaderBlock* headers_out) {
  92   // Lower-case header names, and coalesce multiple values delimited by \0.
  93   // Also add the fixed status header.
  94   std::string name, value;
  95   void* it = NULL;
  96   while (headers.EnumerateHeaderLines(&it, &name, &value)) {
  97     base::StringToLowerASCII(&name);
  98     if (headers_out->find(name) == headers_out->end()) {
  99       (*headers_out)[name] = value;
 100     } else {
 101       (*headers_out)[name] += std::string(1, '\0') + value;
 102     }
 103   }
 104   (*headers_out)[":status"] = base::IntToString(headers.response_code());
 105 }
 106
 107 // static
 108 bool HpackHuffmanAggregator::IsCrossOrigin(const HttpRequestInfo& request) {
 109   // Require that the request is top-level, or that it shares
 110   // an origin with its referer.
 111   HostPortPair endpoint = HostPortPair(request.url.HostNoBrackets(),
 112                                        request.url.EffectiveIntPort());
 113   if ((request.load_flags & LOAD_MAIN_FRAME) == 0) {
 114     std::string referer_str;
 115     if (!request.extra_headers.GetHeader(HttpRequestHeaders::kReferer,
 116                                          &referer_str)) {
 117       // Require a referer.
 118       return true;
 119     }
 120     GURL referer(referer_str);
 121     HostPortPair referer_endpoint = HostPortPair(referer.HostNoBrackets(),
 122                                                  referer.EffectiveIntPort());
 123     if (!endpoint.Equals(referer_endpoint)) {
 124       // Cross-origin request.
 125       return true;
 126     }
 127   }
 128   return false;
 129 }
 130
 131 HpackEncoder* HpackHuffmanAggregator::ObtainEncoder(const SpdySessionKey& key) {
 132   for (OriginEncoders::iterator it = encoders_.begin();
 133        it != encoders_.end(); ++it) {
 134     if (key.Equals(it->first)) {
 135       // Move to head of list and return.
 136       OriginEncoder origin_encoder = *it;
 137       encoders_.erase(it);
 138       encoders_.push_front(origin_encoder);
 139       return origin_encoder.second;
 140     }
 141   }
 142   // Not found. Create a new encoder, evicting one if needed.
 143   encoders_.push_front(std::make_pair(
 144       key, new HpackEncoder(ObtainHpackHuffmanTable())));
 145   if (encoders_.size() > max_encoders_) {
 146     delete encoders_.back().second;
 147     encoders_.pop_back();
 148   }
 149   encoders_.front().second->SetCharCountsStorage(&counts_, &total_counts_);
 150   return encoders_.front().second;
 151 }
 152
 153 void HpackHuffmanAggregator::PublishCounts() {
 154   // base::Histogram requires that values be 1-indexed.
 155   const size_t kRangeMin = 1;
 156   const size_t kRangeMax = counts_.size() + 1;
 157   const size_t kBucketCount = kRangeMax + 1;
 158
 159   base::BucketRanges ranges(kBucketCount + 1);
 160   for (size_t i = 0; i != ranges.size(); ++i) {
 161     ranges.set_range(i, i);
 162   }
 163   ranges.ResetChecksum();
 164
 165   // Copy |counts_| into a SampleVector.
 166   base::SampleVector samples(&ranges);
 167   for (size_t i = 0; i != counts_.size(); ++i) {
 168     samples.Accumulate(i + 1, counts_[i]);
 169   }
 170
 171   STATIC_HISTOGRAM_POINTER_BLOCK(
 172       kHistogramName,
 173       AddSamples(samples),
 174       base::LinearHistogram::FactoryGet(
 175           kHistogramName, kRangeMin, kRangeMax, kBucketCount,
 176           base::HistogramBase::kUmaTargetedHistogramFlag));
 177
 178   // Clear counts.
 179   counts_.assign(counts_.size(), 0);
 180   total_counts_ = 0;
 181 }
 182
 183 }  // namespace net