QuicServer: Use Chrome's header parsing rather than Balsa

net/quic/quic_in_memory_cache.h

Index: net/quic/quic_in_memory_cache.h
diff --git a/net/quic/quic_in_memory_cache.h b/net/quic/quic_in_memory_cache.h
index 32dc8d4cf0c587af01006a5b5ceaa25eb73217a2..657bcd9028202fbfa65c6ae7876411d501acd18d 100644
--- a/net/quic/quic_in_memory_cache.h
+++ b/net/quic/quic_in_memory_cache.h
@@ -11,10 +11,8 @@
 #include "base/file_util.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_piece.h"
-#include "net/base/net_export.h"
-#include "net/tools/balsa/balsa_frame.h"
-#include "net/tools/balsa/balsa_headers.h"
-#include "net/tools/balsa/noop_balsa_visitor.h"
+#include "net/http/http_response_headers.h"
+#include "url/gurl.h"

[wtc, 2014/06/25 22:22:24]

A forward declaration of class GURL should be enough because this header only
uses (const) references to GURL.

[dmziegler, 2014/06/26 01:23:28]

Done.

 
 template <typename T> struct DefaultSingletonTraits;
 
@@ -42,25 +40,23 @@ class QuicInMemoryCache {
   // Container for response header/body pairs.
   class Response {
    public:
-    Response() : response_type_(REGULAR_RESPONSE) {}
-    ~Response() {}
+    Response();
+    ~Response();
 
     SpecialResponseType response_type() const { return response_type_; }
-    const BalsaHeaders& headers() const { return headers_; }
+    scoped_refptr<HttpResponseHeaders> headers() const { return headers_; }

[wtc, 2014/06/25 22:22:24]

The headers() getter method can still return a const HttpResponseHeaders
reference. Would that be better?

[dmziegler, 2014/06/26 01:23:29]

Yes, done.

     const base::StringPiece body() const { return base::StringPiece(body_); }
 
    private:
     friend class QuicInMemoryCache;
 
-    void set_headers(const BalsaHeaders& headers) {
-      headers_.CopyFrom(headers);
-    }
-    void set_body(base::StringPiece body) {
-      body.CopyToString(&body_);
+    void set_headers(scoped_refptr<HttpResponseHeaders> headers) {
+      headers_ = headers;
     }
+    void set_body(base::StringPiece body) { body.CopyToString(&body_); }
 
     SpecialResponseType response_type_;
-    BalsaHeaders headers_;
+    scoped_refptr<HttpResponseHeaders> headers_;
     std::string body_;
 
     DISALLOW_COPY_AND_ASSIGN(Response);
@@ -72,26 +68,22 @@ class QuicInMemoryCache {
   // Retrieve a response from this cache for a given request.
   // If no appropriate response exists, NULL is returned.
   // Currently, responses are selected based on request URI only.
-  const Response* GetResponse(const BalsaHeaders& request_headers) const;
+  const Response* GetResponse(const GURL& url) const;
 
   // Adds a simple response to the cache.  The response headers will
   // only contain the "content-length" header with the lenght of |body|.
-  void AddSimpleResponse(base::StringPiece method,
-                         base::StringPiece path,
-                         base::StringPiece version,
+  void AddSimpleResponse(base::StringPiece path,
                          base::StringPiece response_code,
                          base::StringPiece response_detail,
                          base::StringPiece body);
 
   // Add a response to the cache.
-  void AddResponse(const BalsaHeaders& request_headers,
-                   const BalsaHeaders& response_headers,
+  void AddResponse(const GURL& url,
+                   scoped_refptr<HttpResponseHeaders> response_headers,
                    base::StringPiece response_body);
 
   // Simulate a special behavior at a particular path.
-  void AddSpecialResponse(base::StringPiece method,
-                          base::StringPiece path,
-                          base::StringPiece version,
+  void AddSpecialResponse(base::StringPiece path,
                           SpecialResponseType response_type);
 
  private:
@@ -106,8 +98,6 @@ class QuicInMemoryCache {
 
   void Initialize();
 
-  std::string GetKey(const BalsaHeaders& response_headers) const;
-
   // Cached responses.
   ResponseMap responses_;