Cleanup: have common HttpResponseHeaders routine to update with range

net/http/http_response_headers.cc

 // Copyright (c) 2012 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/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/escape.h"
+#include "net/http/http_byte_range.h"
 #include "net/http/http_util.h"
 
 using base::StringPiece;
 using base::Time;
 using base::TimeDelta;
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 
@@ skipping 333 matching lines @@
 void HttpResponseHeaders::ReplaceStatusLine(const std::string& new_status) {
   CheckDoesNotHaveEmbededNulls(new_status);
   // Copy up to the null byte.  This just copies the status line.
   std::string new_raw_headers(new_status);
   new_raw_headers.push_back('\0');
 
   HeaderSet empty_to_remove;
   MergeWithHeaders(new_raw_headers, empty_to_remove);
 }
 
+void HttpResponseHeaders::UpdateWithNewRange(
+    const HttpByteRange& byte_range,
+    int64 resource_size,
+    bool replace_status_line) {
+  DCHECK(byte_range.IsValid());

[mmenke, 2014/03/06 18:18:48]

Maybe add:

DCHECK(!byte_range.suffix_length());
DCHECK_NE(-1, byte_range.last_byte_position());

[rvargas (doing something else), 2014/03/06 19:24:00]

Excellent point. Now that this lives here we cannot assume where the byte range
comes from.

I think the checks that we need are actually
HasFirstBytePosition/HasLastBytePosition. That implies a valid, already bounded
range regardless of how it was originally created.

IsValid by itself accepts unbounded data, and having a suffix is ok as long as
the struct goes at some point through ComputeBounds, so using those checks here
is not appropriate.

[kinuko, 2014/03/07 05:05:14]

Added DCHECKs for HasFirstBytePosition/HasLastBytePosition. (I wasn't aware that
IsValid accepts unbounded range)

+
+  const char kLengthHeader[] = "Content-Length";
+  const char kRangeHeader[] = "Content-Range";
+
+  RemoveHeader(kLengthHeader);
+  RemoveHeader(kRangeHeader);
+
+  int64 start = byte_range.first_byte_position();
+  int64 end = byte_range.last_byte_position();
+  int64 range_len = end - start + 1;
+
+  if (replace_status_line)
+    ReplaceStatusLine("HTTP/1.1 206 Partial Content");
+
+  AddHeader(base::StringPrintf("%s: bytes %" PRId64 "-%" PRId64 "/%" PRId64,
+                               kRangeHeader, start, end, resource_size));
+  AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader, range_len));
+}
+
 void HttpResponseHeaders::Parse(const std::string& raw_input) {
   raw_headers_.reserve(raw_input.size());
 
   // ParseStatusLine adds a normalized status line to raw_headers_
   std::string::const_iterator line_begin = raw_input.begin();
   std::string::const_iterator line_end =
       std::find(line_begin, raw_input.end(), '\0');
   // has_headers = true, if there is any data following the status line.
   // Used by ParseStatusLine() to decide if a HTTP/0.9 is really a HTTP/1.0.
   bool has_headers = (line_end != raw_input.end() &&
@@ skipping 1053 matching lines @@
   iter = NULL;
   while (EnumerateHeader(&iter, "via", &value))
     if (value == kDeprecatedChromeProxyViaValue)
       return true;
 
   return false;
 }
 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 
 }  // namespace net