Adds response trailers to the QuicInMemoryCache's Responses. Currently unused, this is preparation …

net/tools/quic/quic_in_memory_cache.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_TOOLS_QUIC_QUIC_IN_MEMORY_CACHE_H_
 #define NET_TOOLS_QUIC_QUIC_IN_MEMORY_CACHE_H_
 
 #include <map>
 #include <string>
 
@@ skipping 48 matching lines @@
   };
 
   // Container for response header/body pairs.
   class Response {
    public:
     Response();
     ~Response();
 
     SpecialResponseType response_type() const { return response_type_; }
     const SpdyHeaderBlock& headers() const { return headers_; }
+    const SpdyHeaderBlock& trailers() const { return trailers_; }
     const base::StringPiece body() const { return base::StringPiece(body_); }
 
     void set_response_type(SpecialResponseType response_type) {
       response_type_ = response_type;
     }
     void set_headers(const SpdyHeaderBlock& headers) {
       headers_ = headers;
     }
+    void set_trailers(const SpdyHeaderBlock& trailers) { trailers_ = trailers; }
     void set_body(base::StringPiece body) {
       body.CopyToString(&body_);
     }
 
    private:
     SpecialResponseType response_type_;
     SpdyHeaderBlock headers_;
-    string body_;
+    SpdyHeaderBlock trailers_;
+    std::string body_;
 
     DISALLOW_COPY_AND_ASSIGN(Response);
   };
 
   // Returns the singleton instance of the cache.
   static QuicInMemoryCache* GetInstance();
 
   // Retrieve a response from this cache for a given host and path..
   // If no appropriate response exists, nullptr is returned.
   const Response* GetResponse(base::StringPiece host,
@@ skipping 16 matching lines @@
       int response_code,
       StringPiece body,
       list<ServerPushInfo> push_resources);
 
   // Add a response to the cache.
   void AddResponse(base::StringPiece host,
                    base::StringPiece path,
                    const SpdyHeaderBlock& response_headers,
                    base::StringPiece response_body);
 
+  // Add a response, with trailers, to the cache.
+  void AddResponse(base::StringPiece host,
+                   base::StringPiece path,
+                   const SpdyHeaderBlock& response_headers,
+                   base::StringPiece response_body,
+                   const SpdyHeaderBlock& response_trailers);
+
   // Simulate a special behavior at a particular path.
   void AddSpecialResponse(base::StringPiece host,
                           base::StringPiece path,
                           SpecialResponseType response_type);
 
   // Sets a default response in case of cache misses.  Takes ownership of
   // 'response'.
   void AddDefaultResponse(Response* response);
 
   // |cache_cirectory| can be generated using `wget -p --save-headers <url>`.
@@ skipping 10 matching lines @@
 
   QuicInMemoryCache();
   ~QuicInMemoryCache();
 
   void ResetForTests();
 
   void AddResponseImpl(base::StringPiece host,
                        base::StringPiece path,
                        SpecialResponseType response_type,
                        const SpdyHeaderBlock& response_headers,
-                       base::StringPiece response_body);
+                       base::StringPiece response_body,
+                       const SpdyHeaderBlock& response_trailers);
 
   string GetKey(base::StringPiece host, base::StringPiece path) const;
 
   // Add some server push urls with given responses for specified
   // request if these push resources are not associated with this request yet.
   void MaybeAddServerPushResources(StringPiece request_host,
                                    StringPiece request_path,
                                    list<ServerPushInfo> push_resources);
 
   // Check if push resource(push_host/push_path) associated with given request
@@ skipping 10 matching lines @@
   // A map from request URL to associated server push responses (if any).
   std::multimap<string, ServerPushInfo> server_push_resources_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicInMemoryCache);
 };
 
 }  // namespace tools
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_IN_MEMORY_CACHE_H_