Cleaned up the API of HttpUtil::ParseContentRangeHeader().

net/http/http_util.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 parsing content-types were borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_util.h"
 
 #include <algorithm>
@@ skipping 253 matching lines @@
   return !ranges->empty();
 }
 
 // static
 // From RFC 2616 14.16:
 // content-range-spec =
 //     bytes-unit SP byte-range-resp-spec "/" ( instance-length | "*" )
 // byte-range-resp-spec = (first-byte-pos "-" last-byte-pos) | "*"
 // instance-length = 1*DIGIT
 // bytes-unit = "bytes"
-bool HttpUtil::ParseContentRangeHeader(base::StringPiece content_range_spec,
-                                       int64_t* first_byte_position,
-                                       int64_t* last_byte_position,
-                                       int64_t* instance_length) {
+bool HttpUtil::ParseContentRangeHeaderFor206(
+    base::StringPiece content_range_spec,
+    int64_t* first_byte_position,
+    int64_t* last_byte_position,
+    int64_t* instance_length) {
   *first_byte_position = *last_byte_position = *instance_length = -1;
   content_range_spec = TrimLWS(content_range_spec);
 
   size_t space_position = content_range_spec.find(' ');
   if (space_position == base::StringPiece::npos)
     return false;
 
   // Invalid header if it doesn't contain "bytes-unit".
   if (!base::LowerCaseEqualsASCII(
           TrimLWS(content_range_spec.substr(0, space_position)), "bytes")) {
     return false;
   }
 
-  size_t slash_position = content_range_spec.find('/', space_position + 1);
+  size_t minus_position = content_range_spec.find('-', space_position + 1);
+  if (minus_position == base::StringPiece::npos)
+    return false;
+  size_t slash_position = content_range_spec.find('/', minus_position + 1);
   if (slash_position == base::StringPiece::npos)
     return false;
 
-  // Obtain the part behind the space and before slash.
-  base::StringPiece byte_range_resp_spec = TrimLWS(content_range_spec.substr(
-      space_position + 1, slash_position - (space_position + 1)));
-
-  if (byte_range_resp_spec != "*") {
-    size_t minus_position = byte_range_resp_spec.find('-');
-    if (minus_position == base::StringPiece::npos)
-      return false;
-
-    // Obtain first-byte-pos and last-byte-pos.
-    if (!base::StringToInt64(
-            TrimLWS(byte_range_resp_spec.substr(0, minus_position)),
-            first_byte_position) ||
-        !base::StringToInt64(
-            TrimLWS(byte_range_resp_spec.substr(minus_position + 1)),
-            last_byte_position)) {
-      *first_byte_position = *last_byte_position = -1;
-      return false;
-    }
-    if (*first_byte_position < 0 || *last_byte_position < 0 ||
-        *first_byte_position > *last_byte_position)
-      return false;
+  if (base::StringToInt64(
+          TrimLWS(content_range_spec.substr(
+              space_position + 1, minus_position - (space_position + 1))),
+          first_byte_position) &&
+      *first_byte_position >= 0 &&
+      base::StringToInt64(
+          TrimLWS(content_range_spec.substr(
+              minus_position + 1, slash_position - (minus_position + 1))),
+          last_byte_position) &&
+      *last_byte_position >= *first_byte_position &&
+      base::StringToInt64(
+          TrimLWS(content_range_spec.substr(slash_position + 1)),
+          instance_length) &&
+      *instance_length > *last_byte_position) {
+    return true;
   }
-
-  // Parse the instance-length part.
-  base::StringPiece instance_length_spec =
-      TrimLWS(content_range_spec.substr(slash_position + 1));
-
-  if (base::StartsWith(instance_length_spec, "*",
-                       base::CompareCase::SENSITIVE)) {
-    return false;
-  } else if (!base::StringToInt64(instance_length_spec, instance_length)) {
-    *instance_length = -1;
-    return false;
-  }
-
-  // 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;
+  *first_byte_position = *last_byte_position = *instance_length = -1;
+  return false;
 }
 
 // static
 bool HttpUtil::ParseRetryAfterHeader(const std::string& retry_after_string,
                                      base::Time now,
                                      base::TimeDelta* retry_after) {
   int seconds;
   base::Time time;
   base::TimeDelta interval;
 
@@ skipping 799 matching lines @@
   return true;
 }
 
 bool HttpUtil::NameValuePairsIterator::IsQuote(char c) const {
   if (strict_quotes_)
     return c == '"';
   return HttpUtil::IsQuote(c);
 }
 
 }  // namespace net