Adding Priority field to cookies.

net/cookies/parsed_cookie.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 37 matching lines @@
 #include "base/string_util.h"
 
 namespace {
 
 const char kPathTokenName[] = "path";
 const char kDomainTokenName[] = "domain";
 const char kExpiresTokenName[] = "expires";
 const char kMaxAgeTokenName[] = "max-age";
 const char kSecureTokenName[] = "secure";
 const char kHttpOnlyTokenName[] = "httponly";
+const char kPriorityTokenName[] = "priority";
 
 const char kTerminator[] = "\n\r\0";
 const int kTerminatorLen = sizeof(kTerminator) - 1;
 const char kWhitespace[] = " \t";
 const char kValueSeparator[] = ";";
 const char kTokenSeparator[] = ";=";
 
 // Returns true if |c| occurs in |chars|
 // TODO(erikwright): maybe make this take an iterator, could check for end also?
 inline bool CharIsA(const char c, const char* chars) {
@@ skipping 80 matching lines @@
 }  // namespace
 
 namespace net {
 
 ParsedCookie::ParsedCookie(const std::string& cookie_line)
     : path_index_(0),
       domain_index_(0),
       expires_index_(0),
       maxage_index_(0),
       secure_index_(0),
-      httponly_index_(0) {
+      httponly_index_(0),
+      priority_index_(0) {
 
   if (cookie_line.size() > kMaxCookieSize) {
     VLOG(1) << "Not parsing cookie, too large: " << cookie_line.size();
     return;
   }
 
   ParseTokenValuePairs(cookie_line);
   if (!pairs_.empty())
     SetupAttributes();
 }
 
 ParsedCookie::~ParsedCookie() {
 }
 
 bool ParsedCookie::IsValid() const {
   return !pairs_.empty();
 }
 
+CookiePriority ParsedCookie::Priority() const {
+  return (priority_index_ == 0) ? COOKIE_PRIORITY_DEFAULT :
+      StringToCookiePriority(pairs_[priority_index_].second);
+}
+
 bool ParsedCookie::SetName(const std::string& name) {
   if (!IsValidToken(name))
     return false;
   if (pairs_.empty())
     pairs_.push_back(std::make_pair("", ""));
   pairs_[0].first = name;
   return true;
 }
 
 bool ParsedCookie::SetValue(const std::string& value) {
@@ skipping 22 matching lines @@
 }
 
 bool ParsedCookie::SetIsSecure(bool is_secure) {
   return SetBool(&secure_index_, kSecureTokenName, is_secure);
 }
 
 bool ParsedCookie::SetIsHttpOnly(bool is_http_only) {
   return SetBool(&httponly_index_, kHttpOnlyTokenName, is_http_only);
 }
 
+bool ParsedCookie::SetPriority(const std::string& priority) {
+  return SetString(&priority_index_, kPriorityTokenName, priority);
+}
+
 std::string ParsedCookie::ToCookieLine() const {
   std::string out;
   for (PairList::const_iterator it = pairs_.begin();
        it != pairs_.end(); ++it) {
     if (!out.empty())
       out.append("; ");
     out.append(it->first);
     if (it->first != kSecureTokenName && it->first != kHttpOnlyTokenName) {
       out.append("=");
       out.append(it->second);
@@ skipping 164 matching lines @@
     } else if (pairs_[i].first == kDomainTokenName) {
       domain_index_ = i;
     } else if (pairs_[i].first == kExpiresTokenName) {
       expires_index_ = i;
     } else if (pairs_[i].first == kMaxAgeTokenName) {
       maxage_index_ = i;
     } else if (pairs_[i].first == kSecureTokenName) {
       secure_index_ = i;
     } else if (pairs_[i].first == kHttpOnlyTokenName) {
       httponly_index_ = i;
+    } else if (pairs_[i].first == kPriorityTokenName) {
+      priority_index_ = i;
     } else {
       /* some attribute we don't know or don't care about. */
     }
   }
 }
 
 bool ParsedCookie::SetString(size_t* index,
                              const std::string& key,
                              const std::string& value) {
   if (value.empty()) {
@@ skipping 32 matching lines @@
 }
 
 void ParsedCookie::ClearAttributePair(size_t index) {
   // The first pair (name/value of cookie at pairs_[0]) cannot be cleared.
   // Cookie attributes that don't have a value at the moment, are represented
   // with an index being equal to 0.
   if (index == 0)
     return;
 
   size_t* indexes[] = { &path_index_, &domain_index_, &expires_index_,
-                        &maxage_index_, &secure_index_, &httponly_index_ };
+                        &maxage_index_, &secure_index_, &httponly_index_,
+                        &priority_index_ };
   for (size_t i = 0; i < arraysize(indexes); ++i) {
     if (*indexes[i] == index)
       *indexes[i] = 0;
     else if (*indexes[i] > index)
       --*indexes[i];
   }
   pairs_.erase(pairs_.begin() + index);
 }
 
 }  // namespace