Remove some more uses of *_begin() and _end().

Get us a little closer to removing StringTokenizer's dependency on
std::string iterators.

Bug: 820198
Change-Id: I4bf8c0ed9b518c9a5bcd576ff3c5edaf751e82a3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1576105
Commit-Queue: David Benjamin <davidben@chromium.org>
Reviewed-by: Eric Roman <eroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#654601}

net/http/http_security_headers.cc

@@ -93,18 +93,17 @@ bool ParseHSTSHeader(const std::string& value,
   tokenizer.set_quote_chars("\"");
   std::string unquoted;
   while (tokenizer.GetNext()) {
-    DCHECK(!tokenizer.token_is_delim() ||
-           tokenizer.token_piece().length() == 1);
+    base::StringPiece token = tokenizer.token_piece();
+    DCHECK(!tokenizer.token_is_delim() || token.length() == 1);
     switch (state) {
       case START:
       case DIRECTIVE_END:
-        if (base::IsAsciiWhitespace(*tokenizer.token_begin()))
+        if (base::IsAsciiWhitespace(token[0]))
           continue;
-        if (base::LowerCaseEqualsASCII(tokenizer.token_piece(), "max-age")) {
+        if (base::LowerCaseEqualsASCII(token, "max-age")) {
           state = AFTER_MAX_AGE_LABEL;
           max_age_observed++;
-        } else if (base::LowerCaseEqualsASCII(tokenizer.token_piece(),
-                                              "includesubdomains")) {
+        } else if (base::LowerCaseEqualsASCII(token, "includesubdomains")) {
           state = AFTER_INCLUDE_SUBDOMAINS;
           include_subdomains_observed++;
           include_subdomains_candidate = true;
@@ -114,18 +113,18 @@ bool ParseHSTSHeader(const std::string& value,
         break;
 
       case AFTER_MAX_AGE_LABEL:
-        if (base::IsAsciiWhitespace(*tokenizer.token_begin()))
+        if (base::IsAsciiWhitespace(token[0]))
           continue;
-        if (*tokenizer.token_begin() != '=')
+        if (token[0] != '=')
           return false;
-        DCHECK_EQ(tokenizer.token().length(), 1U);
+        DCHECK_EQ(token.length(), 1U);
         state = AFTER_MAX_AGE_EQUALS;
         break;
 
       case AFTER_MAX_AGE_EQUALS:
-        if (base::IsAsciiWhitespace(*tokenizer.token_begin()))
+        if (base::IsAsciiWhitespace(token[0]))
           continue;
-        unquoted = HttpUtil::Unquote(tokenizer.token_piece());
+        unquoted = HttpUtil::Unquote(token);
         if (!MaxAgeToLimitedInt(unquoted, kMaxHSTSAgeSecs, &max_age_candidate))
           return false;
         state = AFTER_MAX_AGE;
@@ -133,9 +132,9 @@ bool ParseHSTSHeader(const std::string& value,
 
       case AFTER_MAX_AGE:
       case AFTER_INCLUDE_SUBDOMAINS:
-        if (base::IsAsciiWhitespace(*tokenizer.token_begin()))
+        if (base::IsAsciiWhitespace(token[0]))
           continue;
-        else if (*tokenizer.token_begin() == ';')
+        else if (token[0] == ';')
           state = DIRECTIVE_END;
         else
           return false;
@@ -143,7 +142,7 @@ bool ParseHSTSHeader(const std::string& value,
 
       case AFTER_UNKNOWN_LABEL:
         // Consume and ignore the post-label contents (if any).
-        if (*tokenizer.token_begin() != ';')
+        if (token[0] != ';')
           continue;
         state = DIRECTIVE_END;
         break;

net/http/http_util.cc

@@ -249,33 +249,30 @@ bool HttpUtil::ParseRangeHeader(const std::string& ranges_specifier,
     return false;
 
   // Try to extract bytes-unit part.
-  std::string::const_iterator bytes_unit_begin = ranges_specifier.begin();
-  std::string::const_iterator bytes_unit_end = bytes_unit_begin +
-                                               equal_char_offset;
-  std::string::const_iterator byte_range_set_begin = bytes_unit_end + 1;
-  std::string::const_iterator byte_range_set_end = ranges_specifier.end();
+  base::StringPiece bytes_unit =
+      base::StringPiece(ranges_specifier).substr(0, equal_char_offset);
 
-  TrimLWS(&bytes_unit_begin, &bytes_unit_end);
   // "bytes" unit identifier is not found.
-  if (!base::LowerCaseEqualsASCII(
-          base::StringPiece(bytes_unit_begin, bytes_unit_end), "bytes")) {
+  bytes_unit = TrimLWS(bytes_unit);
+  if (!base::LowerCaseEqualsASCII(bytes_unit, "bytes")) {
     return false;
   }
 
+  std::string::const_iterator byte_range_set_begin =
+      ranges_specifier.begin() + equal_char_offset + 1;
+  std::string::const_iterator byte_range_set_end = ranges_specifier.end();
+
   ValuesIterator byte_range_set_iterator(byte_range_set_begin,
                                          byte_range_set_end, ',');
   while (byte_range_set_iterator.GetNext()) {
-    size_t minus_char_offset = byte_range_set_iterator.value_piece().find('-');
+    base::StringPiece value = byte_range_set_iterator.value_piece();
+    size_t minus_char_offset = value.find('-');
     // If '-' character is not found, reports failure.
     if (minus_char_offset == std::string::npos)
       return false;
 
-    std::string::const_iterator first_byte_pos_begin =
-        byte_range_set_iterator.value_begin();
-    std::string::const_iterator first_byte_pos_end =
-        first_byte_pos_begin +  minus_char_offset;
-    TrimLWS(&first_byte_pos_begin, &first_byte_pos_end);
-    std::string first_byte_pos(first_byte_pos_begin, first_byte_pos_end);
+    base::StringPiece first_byte_pos = value.substr(0, minus_char_offset);
+    first_byte_pos = TrimLWS(first_byte_pos);
 
     HttpByteRange range;
     // Try to obtain first-byte-pos.
@@ -286,12 +283,8 @@ bool HttpUtil::ParseRangeHeader(const std::string& ranges_specifier,
       range.set_first_byte_position(first_byte_position);
     }
 
-    std::string::const_iterator last_byte_pos_begin =
-        byte_range_set_iterator.value_begin() + minus_char_offset + 1;
-    std::string::const_iterator last_byte_pos_end =
-        byte_range_set_iterator.value_end();
-    TrimLWS(&last_byte_pos_begin, &last_byte_pos_end);
-    std::string last_byte_pos(last_byte_pos_begin, last_byte_pos_end);
+    base::StringPiece last_byte_pos = value.substr(minus_char_offset + 1);
+    last_byte_pos = TrimLWS(last_byte_pos);
 
     // We have last-byte-pos or suffix-byte-range-spec in this case.
     if (!last_byte_pos.empty()) {
@@ -774,7 +767,7 @@ std::string HttpUtil::ConvertHeadersBackToHTTPResponse(const std::string& str) {
   std::string disassembled_headers;
   base::StringTokenizer tokenizer(str, std::string(1, '\0'));
   while (tokenizer.GetNext()) {
-    disassembled_headers.append(tokenizer.token_begin(), tokenizer.token_end());
+    tokenizer.token_piece().AppendToString(&disassembled_headers);
     disassembled_headers.append("\r\n");
   }
   disassembled_headers.append("\r\n");