Use HttpRequestHeaders for extra_headers.

net/http/partial_data.cc

 // Copyright (c) 2009 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/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.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 = Int64ToString(start);
+  if (end >= 0)
+    my_end = Int64ToString(end);
+
+  headers->SetHeader(
+      HttpRequestHeaders::kRange,
+      StringPrintf("bytes=%s-%s", my_start.c_str(), my_end.c_str()));
 }
 
-namespace net {
+}  // namespace
 
-bool PartialData::Init(const std::string& headers) {
+bool PartialData::Init(const HttpRequestHeaders& headers) {
+  std::string range_header;
+  if (!headers.GetHeader(HttpRequestHeaders::kRange, &range_header))
+    return false;
+
   std::vector<HttpByteRange> ranges;
-  if (!HttpUtil::ParseRanges(headers, &ranges) || ranges.size() != 1)
+  if (!HttpUtil::ParseRangeHeader(range_header, &ranges) || ranges.size() != 1)
     return false;
 
   // We can handle this range request.
   byte_range_ = ranges[0];
   if (!byte_range_.IsValid())
     return false;
 
   resource_size_ = 0;
   current_range_start_ = byte_range_.first_byte_position();
   return true;
 }
 
-void PartialData::SetHeaders(const std::string& headers) {
-  DCHECK(extra_headers_.empty());
-  extra_headers_ = headers;
+void PartialData::SetHeaders(const HttpRequestHeaders& headers) {
+  DCHECK(extra_headers_.IsEmpty());
+  extra_headers_.CopyFrom(headers);
 }
 
-void PartialData::RestoreHeaders(std::string* headers) const {
+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->assign(extra_headers_);
+  headers->CopyFrom(extra_headers_);
   if (byte_range_.IsValid())
     AddRangeHeader(current_range_start_, end, headers);
 }
 
 int PartialData::PrepareCacheValidation(disk_cache::Entry* entry,
-                                        std::string* headers) {
+                                        HttpRequestHeaders* headers) {
   DCHECK(current_range_start_ >= 0);
 
   // Scan the disk cache for the first cached portion within this range.
   int64 range_len = byte_range_.HasLastBytePosition() ?
       byte_range_.last_byte_position() - current_range_start_ + 1 : kint32max;
   if (range_len > kint32max)
     range_len = kint32max;
   int len = static_cast<int32>(range_len);
   if (!len)
     return 0;
@@ skipping 11 matching lines @@
   } else {
     cached_min_len_ = len;
     cached_start_ = current_range_start_;
   }
 
   if (cached_min_len_ < 0) {
     DCHECK(cached_min_len_ != ERR_IO_PENDING);
     return cached_min_len_;
   }
 
-  headers->assign(extra_headers_);
+  headers->CopyFrom(extra_headers_);
 
   if (!cached_min_len_) {
     // We don't have anything else stored.
     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.
@@ skipping 215 matching lines @@
     cached_min_len_ -= result;
     DCHECK(cached_min_len_ >= 0);
   }
 }
 
 void PartialData::OnNetworkReadCompleted(int result) {
   if (result > 0)
     current_range_start_ += result;
 }
 
-// Static.
-void PartialData::AddRangeHeader(int64 start, int64 end, std::string* headers) {
-  DCHECK(start >= 0 || end >= 0);
-  std::string my_start, my_end;
-  if (start >= 0)
-    my_start = Int64ToString(start);
-  if (end >= 0)
-    my_end = Int64ToString(end);
-
-  headers->append(StringPrintf("Range: bytes=%s-%s\r\n", my_start.c_str(),
-                               my_end.c_str()));
-}
-
 }  // namespace net