Parse HPKP report-uri and persist in TransportSecurityPersister

net/http/http_util.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_UTIL_H_
 #define NET_HTTP_HTTP_UTIL_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 11 matching lines @@
 
 namespace net {
 
 class NET_EXPORT HttpUtil {
  public:
   // Returns the absolute URL, to be used for the http request. This url is
   // made up of the protocol, host, [port], path, [query]. Everything else
   // is stripped (username, password, reference).
   static std::string SpecForRequest(const GURL& url);
 
-  // Locates the next occurance of delimiter in line, skipping over quoted
-  // strings (e.g., commas will not be treated as delimiters if they appear
-  // within a quoted string).  Returns the offset of the found delimiter or
-  // line.size() if no delimiter was found.
-  static size_t FindDelimiter(const std::string& line,
-                              size_t search_start,
-                              char delimiter);
-
   // Parses the value of a Content-Type header.  The resulting mime_type and
   // charset values are normalized to lowercase.  The mime_type and charset
   // output values are only modified if the content_type_str contains a mime
   // type and charset value, respectively.  The boundary output value is
   // optional and will be assigned the (quoted) value of the boundary
   // paramter, if any.
   static void ParseContentType(const std::string& content_type_str,
                                std::string* mime_type,
                                std::string* charset,
                                bool* had_charset,
@@ skipping 266 matching lines @@
 
   // Iterates over a delimited sequence of name-value pairs in an HTTP header.
   // Each pair consists of a token (the name), an equals sign, and either a
   // token or quoted-string (the value). Arbitrary HTTP LWS is permitted outside
   // of and between names, values, and delimiters.
   //
   // String iterators returned from this class' methods may be invalidated upon
   // calls to GetNext() or after the NameValuePairsIterator is destroyed.
   class NET_EXPORT NameValuePairsIterator {
    public:
+    // Whether or not values are optional. VALUES_OPTIONAL allows
+    // e.g. name1=value1;name2;name3=value3, whereas VALUES_NOT_OPTIONAL
+    // will treat it as a parse error because name2 does not have a
+    // corresponding equals sign.
+    enum OptionalValues { VALUES_OPTIONAL, VALUES_NOT_OPTIONAL };
+
+    NameValuePairsIterator(std::string::const_iterator begin,
+                           std::string::const_iterator end,
+                           char delimiter,
+                           OptionalValues optional_values);
+
+    // Treats values as not optional by default (VALUES_NOT_OPTIONAL).
     NameValuePairsIterator(std::string::const_iterator begin,
                            std::string::const_iterator end,
                            char delimiter);
+
     ~NameValuePairsIterator();
 
     // Advances the iterator to the next pair, if any.  Returns true if there
     // is a next pair.  Use name* and value* methods to access the resultant
     // value.
     bool GetNext();
 
     // Returns false if there was a parse error.
     bool valid() const { return valid_; }
 
     // The name of the current name-value pair.
     std::string::const_iterator name_begin() const { return name_begin_; }
     std::string::const_iterator name_end() const { return name_end_; }
     std::string name() const { return std::string(name_begin_, name_end_); }
 
     // The value of the current name-value pair.
     std::string::const_iterator value_begin() const {
       return value_is_quoted_ ? unquoted_value_.begin() : value_begin_;
     }
     std::string::const_iterator value_end() const {
       return value_is_quoted_ ? unquoted_value_.end() : value_end_;
     }
     std::string value() const {
       return value_is_quoted_ ? unquoted_value_ : std::string(value_begin_,
                                                               value_end_);
     }
 
+    bool value_is_quoted() const { return value_is_quoted_; }
+
     // The value before unquoting (if any).
     std::string raw_value() const { return std::string(value_begin_,
                                                        value_end_); }
 
    private:
     HttpUtil::ValuesIterator props_;
     bool valid_;
 
     std::string::const_iterator name_begin_;
     std::string::const_iterator name_end_;
 
     std::string::const_iterator value_begin_;
     std::string::const_iterator value_end_;
 
     // Do not store iterators into this string. The NameValuePairsIterator
     // is copyable/assignable, and if copied the copy's iterators would point
     // into the original's unquoted_value_ member.
     std::string unquoted_value_;
 
     bool value_is_quoted_;
+
+    // True if values are required for each name/value pair; false if a
+    // name is permitted to appear without a corresponding value.
+    bool values_optional_;
   };
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_UTIL_H_