Add histogram for HTTP response codes

net/http/http_response_headers.cc

 // Copyright (c) 2010 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.
 
 // The rules for header parsing were borrowed from Firefox:
 // http://lxr.mozilla.org/seamonkey/source/netwerk/protocol/http/src/nsHttpResponseHead.cpp
 // The rules for parsing content-types were also borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_response_headers.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/escape.h"
 #include "net/http/http_util.h"
 
 using base::Time;
 using base::TimeDelta;
 
@@ skipping 53 matching lines @@
 
 bool ShouldUpdateHeader(const std::string::const_iterator& name_begin,
                         const std::string::const_iterator& name_end) {
   for (size_t i = 0; i < arraysize(kNonUpdatedHeaders); ++i) {
     if (LowerCaseEqualsASCII(name_begin, name_end, kNonUpdatedHeaders[i]))
       return false;
   }
   return true;
 }
 
+// Functions for histogram initialization.  The code 0 is put in the
+// response map to track response codes that are invalid.
+// TODO(gavinp): Greatly prune the collected codes once we learn which
+// ares are not sent in practice, to reduce upload size & memory use.
+
+enum { kHistogramMinHttpResponseCode = 100,
+       kHistogramMaxHttpResponseCode = 599 };

[wtc, 2011/01/25 18:38:00]

This should be formatted as

enum {
    kHistogramMinHttpResponseCode = 100,
    kHistogramMaxHttpResponseCode = 599
};

[gavinp, 2011/01/26 01:42:45]

Done.

+
+std::vector<int> GetAllHttpResponseCodes() {
+  std::vector<int> codes;
+  codes.reserve(
+      kHistogramMaxHttpResponseCode - kHistogramMinHttpResponseCode + 2);
+  codes.push_back(0);
+  for (int i = kHistogramMinHttpResponseCode;
+       i <= kHistogramMaxHttpResponseCode;++i)

[wtc, 2011/01/25 18:38:00]

Document what the 0 status code added on line 101 means.

Nit: add a space before ++i.

[gavinp, 2011/01/26 01:42:45]

Done.

[gavinp, 2011/01/26 01:42:45]

Done.

+    codes.push_back(i);
+  return codes;
+}
+
+int MapHttpResponseCode(const int code) {

[wtc, 2011/01/25 18:38:00]

Nit: remove the 'const' from the function parameter.

[gavinp, 2011/01/26 01:42:45]

Done.

+  if (kHistogramMinHttpResponseCode <= code &&
+      code <= kHistogramMaxHttpResponseCode)
+    return code;
+  return 0;
+}
+
 }  // namespace
 
 struct HttpResponseHeaders::ParsedHeader {
   // A header "continuation" contains only a subsequent value for the
   // preceding header.  (Header values are comma separated.)
   bool is_continuation() const { return name_begin == name_end; }
 
   std::string::const_iterator name_begin;
   std::string::const_iterator name_end;
   std::string::const_iterator value_begin;
   std::string::const_iterator value_end;
 };
 
 //-----------------------------------------------------------------------------
 
 HttpResponseHeaders::HttpResponseHeaders(const std::string& raw_input)
     : response_code_(-1) {
   Parse(raw_input);
+
+  // The most important thing to do with this histogram is find out the
+  // existence of unusual HTTP response codes.  As it happens right now,
+  // there aren't double-constructions of response headers using this
+  // constructor, so our counts should also be accurate, without
+  // instantiating the histogram in two places.
+  UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.HttpResponseCode",
+                                   MapHttpResponseCode(response_code_),
+                                   GetAllHttpResponseCodes());

[wtc, 2011/01/25 18:38:00]

It is wasteful to build the std::vector<int> of codes every
time.  There must be a way to avoid this.

[gavinp, 2011/01/26 01:42:45]

Added a comment documenting that this is not what's occuring.

 }
 
 HttpResponseHeaders::HttpResponseHeaders(const Pickle& pickle, void** iter)
     : response_code_(-1) {
   std::string raw_input;
   if (pickle.ReadString(iter, &raw_input))
     Parse(raw_input);
 }
 
 void HttpResponseHeaders::Persist(Pickle* pickle, PersistOptions options) {
@@ skipping 1091 matching lines @@
   // We have all the values; let's verify that they make sense for a 206
   // response.
   if (*first_byte_position < 0 || *last_byte_position < 0 ||
       *instance_length < 0 || *instance_length - 1 < *last_byte_position)
     return false;
 
   return true;
 }
 
 }  // namespace net