Make SpdyHeaderBlock non-copyable.

net/tools/quic/quic_in_memory_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_in_memory_cache.h"
 
+#include <utility>
+
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/spdy/spdy_http_utils.h"
@@ skipping 56 matching lines @@
  private:
   scoped_refptr<HttpResponseHeaders> http_headers_;
   string url_;
   list<std::unique_ptr<string>> push_url_values_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceFileImpl);
 };
 
 }  // namespace
 
-QuicInMemoryCache::ServerPushInfo::ServerPushInfo(
-    GURL request_url,
-    const SpdyHeaderBlock& headers,
-    net::SpdyPriority priority,
-    string body)
+QuicInMemoryCache::ServerPushInfo::ServerPushInfo(GURL request_url,
+                                                  SpdyHeaderBlock headers,
+                                                  net::SpdyPriority priority,
+                                                  string body)
     : request_url(request_url),
-      headers(headers),
+      headers(std::move(headers)),
       priority(priority),
       body(body) {}
 
-QuicInMemoryCache::ServerPushInfo::ServerPushInfo(const ServerPushInfo& other) =
-    default;
+QuicInMemoryCache::ServerPushInfo::ServerPushInfo(const ServerPushInfo& other)
+    : request_url(other.request_url),
+      headers(other.headers.Clone()),
+      priority(other.priority),
+      body(other.body) {}
 
 QuicInMemoryCache::Response::Response() : response_type_(REGULAR_RESPONSE) {}
 
 QuicInMemoryCache::Response::~Response() {}
 
 QuicInMemoryCache::ResourceFile::ResourceFile(const base::FilePath& file_name)
     : file_name_(file_name), file_name_string_(file_name.AsUTF8Unsafe()) {}
 
 QuicInMemoryCache::ResourceFile::~ResourceFile() {}
 
@@ skipping 48 matching lines @@
 typedef QuicInMemoryCache::ServerPushInfo ServerPushInfo;
 
 void QuicInMemoryCache::AddSimpleResponse(StringPiece host,
                                           StringPiece path,
                                           int response_code,
                                           StringPiece body) {
   SpdyHeaderBlock response_headers;
   response_headers[":status"] = IntToString(response_code);
   response_headers["content-length"] =
       IntToString(static_cast<int>(body.length()));
-  AddResponse(host, path, response_headers, body);
+  AddResponse(host, path, std::move(response_headers), body);
 }
 
 void QuicInMemoryCache::AddSimpleResponseWithServerPushResources(
     StringPiece host,
     StringPiece path,
     int response_code,
     StringPiece body,
     list<ServerPushInfo> push_resources) {
   AddSimpleResponse(host, path, response_code, body);
   MaybeAddServerPushResources(host, path, push_resources);
 }
 
 void QuicInMemoryCache::AddDefaultResponse(Response* response) {
   default_response_.reset(response);
 }
 
 void QuicInMemoryCache::AddResponse(StringPiece host,
                                     StringPiece path,
-                                    const SpdyHeaderBlock& response_headers,
+                                    SpdyHeaderBlock response_headers,
                                     StringPiece response_body) {
-  AddResponseImpl(host, path, REGULAR_RESPONSE, response_headers, response_body,
-                  SpdyHeaderBlock());
+  AddResponseImpl(host, path, REGULAR_RESPONSE, std::move(response_headers),
+                  response_body, SpdyHeaderBlock());
 }
 
 void QuicInMemoryCache::AddResponse(StringPiece host,
                                     StringPiece path,
-                                    const SpdyHeaderBlock& response_headers,
+                                    SpdyHeaderBlock response_headers,
                                     StringPiece response_body,
-                                    const SpdyHeaderBlock& response_trailers) {
-  AddResponseImpl(host, path, REGULAR_RESPONSE, response_headers, response_body,
-                  response_trailers);
+                                    SpdyHeaderBlock response_trailers) {
+  AddResponseImpl(host, path, REGULAR_RESPONSE, std::move(response_headers),
+                  response_body, std::move(response_trailers));
 }
 
 void QuicInMemoryCache::AddSpecialResponse(StringPiece host,
                                            StringPiece path,
                                            SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, SpdyHeaderBlock(), "",
                   SpdyHeaderBlock());
 }
 
 QuicInMemoryCache::QuicInMemoryCache() {}
@@ skipping 27 matching lines @@
     StringPiece 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(), resource_file->body());
+                resource_file->spdy_headers().Clone(), resource_file->body());
 
     resource_files.push_back(std::move(resource_file));
   }
 
   for (const auto& resource_file : resource_files) {
     list<ServerPushInfo> push_resources;
     for (const auto& push_url : resource_file->push_urls()) {
       GURL url(push_url);
       const Response* response = GetResponse(url.host(), url.path());
       if (!response) {
         QUIC_BUG << "Push URL '" << push_url << "' not found.";
         return;
       }
-      push_resources.push_back(ServerPushInfo(url, response->headers(),
+      push_resources.push_back(ServerPushInfo(url, response->headers().Clone(),
                                               net::kV3LowestPriority,
                                               response->body().as_string()));
     }
     MaybeAddServerPushResources(resource_file->host(), resource_file->path(),
                                 push_resources);
   }
 }
 
 list<ServerPushInfo> QuicInMemoryCache::GetServerPushResources(
     string request_url) {
   list<ServerPushInfo> resources;
   auto resource_range = server_push_resources_.equal_range(request_url);
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     resources.push_back(it->second);
   }
   DVLOG(1) << "Found " << resources.size() << " push resources for "
            << request_url;
   return resources;
 }
 
 QuicInMemoryCache::~QuicInMemoryCache() {
   STLDeleteValues(&responses_);
 }
 
-void QuicInMemoryCache::AddResponseImpl(
-    StringPiece host,
-    StringPiece path,
-    SpecialResponseType response_type,
-    const SpdyHeaderBlock& response_headers,
-    StringPiece response_body,
-    const SpdyHeaderBlock& response_trailers) {
+void QuicInMemoryCache::AddResponseImpl(StringPiece host,
+                                        StringPiece path,
+                                        SpecialResponseType response_type,
+                                        SpdyHeaderBlock response_headers,
+                                        StringPiece response_body,
+                                        SpdyHeaderBlock response_trailers) {
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
   string key = GetKey(host, path);
   if (ContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
   Response* new_response = new Response();
   new_response->set_response_type(response_type);
-  new_response->set_headers(response_headers);
+  new_response->set_headers(std::move(response_headers));
   new_response->set_body(response_body);
-  new_response->set_trailers(response_trailers);
+  new_response->set_trailers(std::move(response_trailers));
   DVLOG(1) << "Add response with key " << key;
   responses_[key] = new_response;
 }
 
 string QuicInMemoryCache::GetKey(StringPiece host, StringPiece path) const {
   return host.as_string() + path.as_string();
 }
 
 void QuicInMemoryCache::MaybeAddServerPushResources(
     StringPiece request_host,
@@ skipping 10 matching lines @@
              << " push url " << push_resource.request_url
              << " response headers " << push_resource.headers.DebugString();
     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();
     if (responses_.find(GetKey(host, path)) == responses_.end()) {
       // Add a server push response to responses map, if it is not in the map.
-      SpdyHeaderBlock headers = push_resource.headers;
       StringPiece body = push_resource.body;
       DVLOG(1) << "Add response for push resource: host " << host << " path "
                << path;
-      AddResponse(host, path, headers, body);
+      AddResponse(host, path, push_resource.headers.Clone(), body);
     }
   }
 }
 
 bool QuicInMemoryCache::PushResourceExistsInCache(string original_request_url,
                                                   ServerPushInfo resource) {
   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.spec() == resource.request_url.spec()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net