[WIP] make GURL::path() return a StringPiece

net/cookies/canonical_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 74 matching lines @@
   // The path was supplied in the cookie, we'll take it.
   if (!path_string.empty() && path_string[0] == '/')
     return path_string;
 
   // The path was not supplied in the cookie or invalid, we will default
   // to the current URL path.
   // """Defaults to the path of the request URL that generated the
   //    Set-Cookie response, up to, but not including, the
   //    right-most /."""
   // How would this work for a cookie on /?  We will include it then.
-  const std::string& url_path = url.path();
+  base::StringPiece url_path = url.path();
 
   size_t idx = url_path.find_last_of('/');
 
   // The cookie path was invalid or a single '/'.
   if (idx == 0 || idx == std::string::npos)
     return std::string("/");
 
   // Return up to the rightmost '/'.
-  return url_path.substr(0, idx);
+  return url_path.as_string().substr(0, idx);
 }
 
 // Compares cookies using name, domain and path, so that "equivalent" cookies
 // (per RFC 2965) are equal to each other.
 int PartialCookieOrdering(const CanonicalCookie& a, const CanonicalCookie& b) {
   int diff = a.Name().compare(b.Name());
   if (diff != 0)
     return diff;
 
   diff = a.Domain().compare(b.Domain());
@@ skipping 188 matching lines @@
                           last_access, secure, http_only, same_site, priority));
 }
 
 bool CanonicalCookie::IsEquivalentForSecureCookieMatching(
     const CanonicalCookie& ecc) const {
   return (name_ == ecc.Name() && (ecc.IsDomainMatch(DomainWithoutDot()) ||
                                   IsDomainMatch(ecc.DomainWithoutDot())) &&
           ecc.IsOnPath(Path()));
 }
 
-bool CanonicalCookie::IsOnPath(const std::string& url_path) const {
-
+bool CanonicalCookie::IsOnPath(const base::StringPiece& url_path) const {
   // A zero length would be unsafe for our trailing '/' checks, and
   // would also make no sense for our prefix match.  The code that
   // creates a CanonicalCookie should make sure the path is never zero length,
   // but we double check anyway.
   if (path_.empty())
     return false;
 
   // The Mozilla code broke this into three cases, based on if the cookie path
   // was longer, the same length, or shorter than the length of the url path.
   // I think the approach below is simpler.
@@ skipping 198 matching lines @@
   return true;
 }
 
 std::string CanonicalCookie::DomainWithoutDot() const {
   if (domain_.empty() || domain_[0] != '.')
     return domain_;
   return domain_.substr(1);
 }
 
 }  // namespace net