QUIC - extend QuicInMemoryCache so that simple server can do server push.

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>
 #include <unordered_map>
 
 #include "base/containers/hash_tables.h"
+#include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_piece.h"
+#include "net/http/http_response_headers.h"
 #include "net/quic/spdy_utils.h"
 #include "net/spdy/spdy_framer.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
 using std::string;
 using std::list;
 
 namespace base {
 
@@ skipping 12 matching lines @@
 
 // In-memory cache for HTTP responses.
 // Reads from disk cache generated by:
 // `wget -p --save_headers <url>`
 class QuicInMemoryCache {
  public:
   // A ServerPushInfo contains path of the push request and everything needed in
   // comprising a response for the push request.
   struct ServerPushInfo {
     ServerPushInfo(GURL request_url,
-                   const net::SpdyHeaderBlock& headers,
-                   net::SpdyPriority priority,
+                   const SpdyHeaderBlock& headers,
+                   SpdyPriority priority,
                    string body);
     ServerPushInfo(const ServerPushInfo& other);
     GURL request_url;
-    net::SpdyHeaderBlock headers;
-    net::SpdyPriority priority;
+    SpdyHeaderBlock headers;
+    SpdyPriority priority;
     string body;
   };
 
   enum SpecialResponseType {
     REGULAR_RESPONSE,  // Send the headers and body like a server should.
     CLOSE_CONNECTION,  // Close the connection (sending the close packet).
     IGNORE_REQUEST,    // Do nothing, expect the client to time out.
   };
 
   // Container for response header/body pairs.
@@ skipping 16 matching lines @@
 
    private:
     SpecialResponseType response_type_;
     SpdyHeaderBlock headers_;
     SpdyHeaderBlock trailers_;
     std::string body_;
 
     DISALLOW_COPY_AND_ASSIGN(Response);
   };
 
+  // Class to manage loading a resource file into memory.  There are
+  // two uses: called by InitializeFromDirectory to load resources
+  // from files, and recursively called when said resources specify
+  // server push associations.
+  class ResourceFile {
+   public:
+    explicit ResourceFile(const base::FilePath& file_name);
+    virtual ~ResourceFile();
+
+    // abstract: implementation details are chromium and internal
+    // version specific.
+    virtual void Read() = 0;
+    void SetHostPathFromBase(base::StringPiece base);
+
+    StringPiece host() { return host_; }
+    void set_host(base::StringPiece host) { host_ = host; }
+
+    StringPiece path() { return path_; }
+    void set_path(base::StringPiece path) { path_ = path; }
+
+    SpdyHeaderBlock spdy_headers() { return spdy_headers_; }
+
+    StringPiece body() { return body_; }
+
+    const std::vector<base::StringPiece>& push_urls() { return push_urls_; }
+
+    const std::string& file_name() { return file_name_string_; }
+
+   protected:
+    void HandleXOriginalUrl();
+    void HandlePushUrls(const std::vector<base::StringPiece>& push_urls);
+    StringPiece RemoveScheme(base::StringPiece url);
+
+    const string cache_directory_;
+    const base::FilePath file_name_;
+    const std::string file_name_string_;
+    string file_contents_;
+    base::StringPiece body_;
+    SpdyHeaderBlock spdy_headers_;
+    base::StringPiece x_original_url_;
+    std::vector<base::StringPiece> push_urls_;
+
+   private:
+    base::StringPiece host_;
+    base::StringPiece path_;
+    QuicInMemoryCache* cache_;
+
+    DISALLOW_COPY_AND_ASSIGN(ResourceFile);
+  };
+
   // 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,
                               base::StringPiece path) const;
 
   // Adds a simple response to the cache.  The response headers will
   // only contain the "content-length" header with the length of |body|.
@@ skipping 80 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 net
 
 #endif  // NET_TOOLS_QUIC_QUIC_IN_MEMORY_CACHE_H_