Revert of Parse HPKP report-uri and persist in TransportSecurityPersister

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 25 matching lines @@
     if (line[end] != '\\')
       return end;
   }
   return line.length();
 }
 
 
 // HttpUtil -------------------------------------------------------------------
 
 // static
+size_t HttpUtil::FindDelimiter(const std::string& line,
+                               size_t search_start,
+                               char delimiter) {
+  do {
+    // search_start points to the spot from which we should start looking
+    // for the delimiter.
+    const char delim_str[] = { delimiter, '"', '\'', '\0' };
+    size_t cur_delim_pos = line.find_first_of(delim_str, search_start);
+    if (cur_delim_pos == std::string::npos)
+      return line.length();
+
+    char ch = line[cur_delim_pos];
+    if (ch == delimiter) {
+      // Found delimiter
+      return cur_delim_pos;
+    }
+
+    // We hit the start of a quoted string.  Look for its end.
+    search_start = FindStringEnd(line, cur_delim_pos, ch);
+    if (search_start == line.length())
+      return search_start;
+
+    ++search_start;
+
+    // search_start now points to the first char after the end of the
+    // string, so just go back to the top of the loop and look for
+    // |delimiter| again.
+  } while (true);
+
+  NOTREACHED();
+  return line.length();
+}
+
+// static
 void HttpUtil::ParseContentType(const std::string& content_type_str,
                                 std::string* mime_type,
                                 std::string* charset,
                                 bool* had_charset,
                                 std::string* boundary) {
   const std::string::const_iterator begin = content_type_str.begin();
 
   // Trim leading and trailing whitespace from type.  We include '(' in
   // the trailing trim set to catch media-type comments, which are not at all
   // standard, but may occur in rare cases.
@@ skipping 792 matching lines @@
     // bypass empty values.
     if (value_begin_ != value_end_)
       return true;
   }
   return false;
 }
 
 HttpUtil::NameValuePairsIterator::NameValuePairsIterator(
     std::string::const_iterator begin,
     std::string::const_iterator end,
-    char delimiter,
-    OptionalValues optional_values)
+    char delimiter)
     : props_(begin, end, delimiter),
       valid_(true),
       name_begin_(end),
       name_end_(end),
       value_begin_(end),
       value_end_(end),
-      value_is_quoted_(false),
-      values_optional_(optional_values == VALUES_OPTIONAL) {}
-
-HttpUtil::NameValuePairsIterator::NameValuePairsIterator(
-    std::string::const_iterator begin,
-    std::string::const_iterator end,
-    char delimiter)
-    : NameValuePairsIterator(begin, end, delimiter, VALUES_NOT_OPTIONAL) {}
+      value_is_quoted_(false) {
+}
 
 HttpUtil::NameValuePairsIterator::~NameValuePairsIterator() {}
 
 // We expect properties to be formatted as one of:
 //   name="value"
 //   name='value'
 //   name='\'value\''
 //   name=value
 //   name = value
-//   name (if values_optional_ is true)
+//   name=
 // Due to buggy implementations found in some embedded devices, we also
 // accept values with missing close quotemark (http://crbug.com/39836):
 //   name="value
 bool HttpUtil::NameValuePairsIterator::GetNext() {
   if (!props_.GetNext())
     return false;
 
   // Set the value as everything. Next we will split out the name.
   value_begin_ = props_.value_begin();
   value_end_ = props_.value_end();
   name_begin_ = name_end_ = value_end_;
 
   // Scan for the equals sign.
   std::string::const_iterator equals = std::find(value_begin_, value_end_, '=');
-  if (equals == value_begin_)
-    return valid_ = false;  // Malformed, no name
-  if (equals == value_end_ && !values_optional_)
-    return valid_ = false;  // Malformed, no equals sign and values are required
+  if (equals == value_end_ || equals == value_begin_)
+    return valid_ = false;  // Malformed, no equals sign
 
-  // If an equals sign was found, verify that it wasn't inside of quote marks.
-  if (equals != value_end_) {
-    for (std::string::const_iterator it = value_begin_; it != equals; ++it) {
-      if (HttpUtil::IsQuote(*it))
-        return valid_ = false;  // Malformed, quote appears before equals sign
-    }
+  // Verify that the equals sign we found wasn't inside of quote marks.
+  for (std::string::const_iterator it = value_begin_; it != equals; ++it) {
+    if (HttpUtil::IsQuote(*it))
+      return valid_ = false;  // Malformed, quote appears before equals sign
   }
 
   name_begin_ = value_begin_;
   name_end_ = equals;
-  value_begin_ = (equals == value_end_) ? value_end_ : equals + 1;
+  value_begin_ = equals + 1;
 
   TrimLWS(&name_begin_, &name_end_);
   TrimLWS(&value_begin_, &value_end_);
   value_is_quoted_ = false;
   unquoted_value_.clear();
 
-  if (equals != value_end_ && value_begin_ == value_end_) {
-    // Malformed; value is empty
-    return valid_ = false;
-  }
+  if (value_begin_ == value_end_)
+    return valid_ = false;  // Malformed, value is empty
 
   if (HttpUtil::IsQuote(*value_begin_)) {
     // Trim surrounding quotemarks off the value
     if (*value_begin_ != *(value_end_ - 1) || value_begin_ + 1 == value_end_) {
       // NOTE: This is not as graceful as it sounds:
       // * quoted-pairs will no longer be unquoted
       //   (["\"hello] should give ["hello]).
       // * Does not detect when the final quote is escaped
       //   (["value\"] should give [value"])
       ++value_begin_;  // Gracefully recover from mismatching quotes.
     } else {
       value_is_quoted_ = true;
       // Do not store iterators into this. See declaration of unquoted_value_.
       unquoted_value_ = HttpUtil::Unquote(value_begin_, value_end_);
     }
   }
 
   return true;
 }
 
 }  // namespace net