Add QuicStringPiece which is actually StringPiece.

net/tools/quic/quic_http_response_cache.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.
 
 #include "net/tools/quic/quic_http_response_cache.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "net/http/http_util.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_map_util.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/spdy/spdy_http_utils.h"
 
 using base::FilePath;
 using base::IntToString;
-using base::StringPiece;
 using std::string;
 
 namespace net {
 
 QuicHttpResponseCache::ServerPushInfo::ServerPushInfo(QuicUrl request_url,
                                                       SpdyHeaderBlock headers,
                                                       SpdyPriority priority,
                                                       string body)
     : request_url(request_url),
       headers(std::move(headers)),
@@ skipping 28 matching lines @@
     if (pos == string::npos) {
       QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: "
                        << file_name_.value();
       return;
     }
     size_t len = pos - start;
     // Support both dos and unix line endings for convenience.
     if (file_contents_[pos - 1] == '\r') {
       len -= 1;
     }
-    StringPiece line(file_contents_.data() + start, len);
+    QuicStringPiece line(file_contents_.data() + start, len);
     start = pos + 1;
     // Headers end with an empty line.
     if (line.empty()) {
       break;
     }
     // Extract the status from the HTTP first line.
     if (line.substr(0, 4) == "HTTP") {
       pos = line.find(" ");
       if (pos == string::npos) {
         QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: "
@@ skipping 22 matching lines @@
   if (it != spdy_headers_.end()) {
     x_original_url_ = it->second;
     HandleXOriginalUrl();
   }
 
   // X-Push-URL header is a relatively quick way to support sever push
   // in the toy server.  A production server should use link=preload
   // stuff as described in https://w3c.github.io/preload/.
   it = spdy_headers_.find("x-push-url");
   if (it != spdy_headers_.end()) {
-    StringPiece push_urls = it->second;
+    QuicStringPiece push_urls = it->second;
     size_t start = 0;
     while (start < push_urls.length()) {
       size_t pos = push_urls.find('\0', start);
       if (pos == string::npos) {
-        push_urls_.push_back(
-            StringPiece(push_urls.data() + start, push_urls.length() - start));
+        push_urls_.push_back(QuicStringPiece(push_urls.data() + start,
+                                             push_urls.length() - start));
         break;
       }
-      push_urls_.push_back(StringPiece(push_urls.data() + start, pos));
+      push_urls_.push_back(QuicStringPiece(push_urls.data() + start, pos));
       start += pos + 1;
     }
   }
 
-  body_ =
-      StringPiece(file_contents_.data() + start, file_contents_.size() - start);
+  body_ = QuicStringPiece(file_contents_.data() + start,
+                          file_contents_.size() - start);
 }
 
 void QuicHttpResponseCache::ResourceFile::SetHostPathFromBase(
-    StringPiece base) {
+    QuicStringPiece base) {
   size_t path_start = base.find_first_of('/');
   DCHECK_LT(0UL, path_start);
   host_ = base.substr(0, path_start);
   size_t query_start = base.find_first_of(',');
   if (query_start > 0) {
     path_ = base.substr(path_start, query_start - 1);
   } else {
     path_ = base.substr(path_start);
   }
 }
 
-StringPiece QuicHttpResponseCache::ResourceFile::RemoveScheme(StringPiece url) {
+QuicStringPiece QuicHttpResponseCache::ResourceFile::RemoveScheme(
+    QuicStringPiece url) {
   if (QuicTextUtils::StartsWith(url, "https://")) {
     url.remove_prefix(8);
   } else if (QuicTextUtils::StartsWith(url, "http://")) {
     url.remove_prefix(7);
   }
   return url;
 }
 
 void QuicHttpResponseCache::ResourceFile::HandleXOriginalUrl() {
-  StringPiece url(x_original_url_);
+  QuicStringPiece url(x_original_url_);
   // Remove the protocol so we can add it below.
   url = RemoveScheme(url);
   SetHostPathFromBase(url);
 }
 
 const QuicHttpResponseCache::Response* QuicHttpResponseCache::GetResponse(
-    StringPiece host,
-    StringPiece path) const {
+    QuicStringPiece host,
+    QuicStringPiece path) const {
   QuicWriterMutexLock lock(&response_mutex_);
 
   auto it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) {
     DVLOG(1) << "Get response for resource failed: host " << host << " path "
              << path;
     if (default_response_.get()) {
       return default_response_.get();
     }
     return nullptr;
   }
   return it->second.get();
 }
 
 typedef QuicHttpResponseCache::ServerPushInfo ServerPushInfo;
 
-void QuicHttpResponseCache::AddSimpleResponse(StringPiece host,
-                                              StringPiece path,
+void QuicHttpResponseCache::AddSimpleResponse(QuicStringPiece host,
+                                              QuicStringPiece path,
                                               int response_code,
-                                              StringPiece body) {
+                                              QuicStringPiece body) {
   SpdyHeaderBlock response_headers;
   response_headers[":status"] = QuicTextUtils::Uint64ToString(response_code);
   response_headers["content-length"] =
       QuicTextUtils::Uint64ToString(body.length());
   AddResponse(host, path, std::move(response_headers), body);
 }
 
 void QuicHttpResponseCache::AddSimpleResponseWithServerPushResources(
-    StringPiece host,
-    StringPiece path,
+    QuicStringPiece host,
+    QuicStringPiece path,
     int response_code,
-    StringPiece body,
+    QuicStringPiece body,
     std::list<ServerPushInfo> push_resources) {
   AddSimpleResponse(host, path, response_code, body);
   MaybeAddServerPushResources(host, path, push_resources);
 }
 
 void QuicHttpResponseCache::AddDefaultResponse(Response* response) {
   QuicWriterMutexLock lock(&response_mutex_);
   default_response_.reset(response);
 }
 
-void QuicHttpResponseCache::AddResponse(StringPiece host,
-                                        StringPiece path,
+void QuicHttpResponseCache::AddResponse(QuicStringPiece host,
+                                        QuicStringPiece path,
                                         SpdyHeaderBlock response_headers,
-                                        StringPiece response_body) {
+                                        QuicStringPiece response_body) {
   AddResponseImpl(host, path, REGULAR_RESPONSE, std::move(response_headers),
                   response_body, SpdyHeaderBlock());
 }
 
-void QuicHttpResponseCache::AddResponse(StringPiece host,
-                                        StringPiece path,
+void QuicHttpResponseCache::AddResponse(QuicStringPiece host,
+                                        QuicStringPiece path,
                                         SpdyHeaderBlock response_headers,
-                                        StringPiece response_body,
+                                        QuicStringPiece response_body,
                                         SpdyHeaderBlock response_trailers) {
   AddResponseImpl(host, path, REGULAR_RESPONSE, std::move(response_headers),
                   response_body, std::move(response_trailers));
 }
 
 void QuicHttpResponseCache::AddSpecialResponse(
-    StringPiece host,
-    StringPiece path,
+    QuicStringPiece host,
+    QuicStringPiece path,
     SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, SpdyHeaderBlock(), "",
                   SpdyHeaderBlock());
 }
 
 QuicHttpResponseCache::QuicHttpResponseCache() {}
 
 void QuicHttpResponseCache::InitializeFromDirectory(
     const string& cache_directory) {
   if (cache_directory.empty()) {
     QUIC_BUG << "cache_directory must not be empty.";
     return;
   }
   QUIC_LOG(INFO)
       << "Attempting to initialize QuicHttpResponseCache from directory: "
       << cache_directory;
   FilePath directory(FilePath::FromUTF8Unsafe(cache_directory));
   base::FileEnumerator file_list(directory, true, base::FileEnumerator::FILES);
   std::list<std::unique_ptr<ResourceFile>> resource_files;
   for (FilePath file_iter = file_list.Next(); !file_iter.empty();
        file_iter = file_list.Next()) {
     // Need to skip files in .svn directories
     if (file_iter.value().find(FILE_PATH_LITERAL("/.svn/")) != string::npos) {
       continue;
     }
 
     std::unique_ptr<ResourceFile> resource_file(new ResourceFile(file_iter));
 
     // Tease apart filename into host and path.
-    StringPiece base(resource_file->file_name());
+    QuicStringPiece base(resource_file->file_name());
     base.remove_prefix(cache_directory.length());
     if (base[0] == '/') {
       base.remove_prefix(1);
     }
 
     resource_file->SetHostPathFromBase(base);
     resource_file->Read();
 
     AddResponse(resource_file->host(), resource_file->path(),
                 resource_file->spdy_headers().Clone(), resource_file->body());
@@ skipping 33 matching lines @@
   return resources;
 }
 
 QuicHttpResponseCache::~QuicHttpResponseCache() {
   {
     QuicWriterMutexLock lock(&response_mutex_);
     responses_.clear();
   }
 }
 
-void QuicHttpResponseCache::AddResponseImpl(StringPiece host,
-                                            StringPiece path,
+void QuicHttpResponseCache::AddResponseImpl(QuicStringPiece host,
+                                            QuicStringPiece path,
                                             SpecialResponseType response_type,
                                             SpdyHeaderBlock response_headers,
-                                            StringPiece response_body,
+                                            QuicStringPiece response_body,
                                             SpdyHeaderBlock response_trailers) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
   string key = GetKey(host, path);
   if (QuicContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
   auto new_response = QuicMakeUnique<Response>();
   new_response->set_response_type(response_type);
   new_response->set_headers(std::move(response_headers));
   new_response->set_body(response_body);
   new_response->set_trailers(std::move(response_trailers));
   QUIC_DVLOG(1) << "Add response with key " << key;
   responses_[key] = std::move(new_response);
 }
 
-string QuicHttpResponseCache::GetKey(StringPiece host, StringPiece path) const {
+string QuicHttpResponseCache::GetKey(QuicStringPiece host,
+                                     QuicStringPiece path) const {
   return host.as_string() + path.as_string();
 }
 
 void QuicHttpResponseCache::MaybeAddServerPushResources(
-    StringPiece request_host,
-    StringPiece request_path,
+    QuicStringPiece request_host,
+    QuicStringPiece request_path,
     std::list<ServerPushInfo> push_resources) {
   string request_url = GetKey(request_host, request_path);
 
   for (const auto& push_resource : push_resources) {
     if (PushResourceExistsInCache(request_url, push_resource)) {
       continue;
     }
 
     QUIC_DVLOG(1) << "Add request-resource association: request url "
                   << request_url << " push url "
                   << push_resource.request_url.ToString()
                   << " response headers "
                   << push_resource.headers.DebugString();
     {
       QuicWriterMutexLock lock(&response_mutex_);
       server_push_resources_.insert(std::make_pair(request_url, push_resource));
     }
     string host = push_resource.request_url.host();
     if (host.empty()) {
       host = request_host.as_string();
     }
     string path = push_resource.request_url.path();
     bool found_existing_response = false;
     {
       QuicWriterMutexLock lock(&response_mutex_);
       found_existing_response = QuicContainsKey(responses_, GetKey(host, path));
     }
     if (!found_existing_response) {
       // Add a server push response to responses map, if it is not in the map.
-      StringPiece body = push_resource.body;
+      QuicStringPiece body = push_resource.body;
       QUIC_DVLOG(1) << "Add response for push resource: host " << host
                     << " path " << path;
       AddResponse(host, path, push_resource.headers.Clone(), body);
     }
   }
 }
 
 bool QuicHttpResponseCache::PushResourceExistsInCache(
     string original_request_url,
     ServerPushInfo resource) {
   QuicWriterMutexLock lock(&response_mutex_);
   auto resource_range =
       server_push_resources_.equal_range(original_request_url);
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     ServerPushInfo push_resource = it->second;
     if (push_resource.request_url.ToString() ==
         resource.request_url.ToString()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net