Net: Standardize HttpByteRange printing

net/http/partial_data.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.
 
 #include "net/http/partial_data.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 namespace net {
 
 namespace {
 
 // The headers that we have to process.
 const char kLengthHeader[] = "Content-Length";
 const char kRangeHeader[] = "Content-Range";
 const int kDataStream = 1;
 
-void AddRangeHeader(int64 start, int64 end, HttpRequestHeaders* headers) {
-  DCHECK(start >= 0 || end >= 0);
-  std::string my_start, my_end;
-  if (start >= 0)
-    my_start = base::Int64ToString(start);
-  if (end >= 0)
-    my_end = base::Int64ToString(end);
-
-  headers->SetHeader(
-      HttpRequestHeaders::kRange,
-      base::StringPrintf("bytes=%s-%s", my_start.c_str(), my_end.c_str()));
-}
-
 }  // namespace
 
 // A core object that can be detached from the Partialdata object at destruction
 // so that asynchronous operations cleanup can be performed.
 class PartialData::Core {
  public:
   // Build a new core object. Lifetime management is automatic.
   static Core* CreateCore(PartialData* owner) {
     return new Core(owner);
   }
@@ skipping 98 matching lines @@
   DCHECK(extra_headers_.IsEmpty());
   extra_headers_.CopyFrom(headers);
 }
 
 void PartialData::RestoreHeaders(HttpRequestHeaders* headers) const {
   DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange());
   int64 end = byte_range_.IsSuffixByteRange() ?
               byte_range_.suffix_length() : byte_range_.last_byte_position();
 
   headers->CopyFrom(extra_headers_);
-  if (!truncated_ && byte_range_.IsValid())
-    AddRangeHeader(current_range_start_, end, headers);
+  if (truncated_ || !byte_range_.IsValid())
+    return;
+
+  if (current_range_start_ < 0) {
+    headers->SetHeader(HttpRequestHeaders::kRange,
+                       HttpByteRange::Suffix(end).GetHeaderValue());
+  } else {
+    headers->SetHeader(HttpRequestHeaders::kRange,
+                       HttpByteRange::Bounded(
+                           current_range_start_, end).GetHeaderValue());
+  }
 }
 
 int PartialData::ShouldValidateCache(disk_cache::Entry* entry,
                                      const CompletionCallback& callback) {
   DCHECK_GE(current_range_start_, 0);
 
   // Scan the disk cache for the first cached portion within this range.
   int len = GetNextRangeLen();
   if (!len)
     return 0;
@@ skipping 44 matching lines @@
     final_range_ = true;
     cached_start_ =
         byte_range_.HasLastBytePosition() ? current_range_start_  + len : 0;
   }
 
   if (current_range_start_ == cached_start_) {
     // The data lives in the cache.
     range_present_ = true;
     if (len == cached_min_len_)
       final_range_ = true;
-    AddRangeHeader(current_range_start_, cached_start_ + cached_min_len_ - 1,
-                   headers);
+    headers->SetHeader(
+        HttpRequestHeaders::kRange,
+        net::HttpByteRange::Bounded(
+            current_range_start_,
+            cached_start_ + cached_min_len_ - 1).GetHeaderValue());
   } else {
     // This range is not in the cache.
-    AddRangeHeader(current_range_start_, cached_start_ - 1, headers);
+    headers->SetHeader(
+        HttpRequestHeaders::kRange,
+        net::HttpByteRange::Bounded(
+            current_range_start_, cached_start_ - 1).GetHeaderValue());
   }
 }
 
 bool PartialData::IsCurrentRangeCached() const {
   return range_present_;
 }
 
 bool PartialData::IsLastRange() const {
   return final_range_;
 }
@@ skipping 251 matching lines @@
   cached_min_len_ = result;
   if (result >= 0)
     result = 1;  // Return success, go ahead and validate the entry.
 
   CompletionCallback cb = callback_;
   callback_.Reset();
   cb.Run(result);
 }
 
 }  // namespace net