Implement server push protocol 2.

net/spdy/spdy_test_util.h

 // Copyright (c) 2010 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_SPDY_SPDY_TEST_UTIL_H_
 #define NET_SPDY_SPDY_TEST_UTIL_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_session_pool.h"
+#include "net/url_request/url_request_context.h"
 
 namespace net {
 
 // NOTE: In GCC, on a Mac, this can't be in an anonymous namespace!
 // This struct holds information used to construct spdy control and data frames.
 struct SpdyHeaderInfo {
   spdy::SpdyControlType kind;
   spdy::SpdyStreamId id;
   spdy::SpdyStreamId assoc_id;
   spdy::SpdyPriority priority;
@@ skipping 73 matching lines @@
 // will vary the most between calls.
 // |tail| is any (relatively constant) header-value pairs to add.
 // |buffer| is the buffer we're filling in.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyPacket(const SpdyHeaderInfo& header_info,
                                      const char* const extra_headers[],
                                      int extra_header_count,
                                      const char* const tail[],
                                      int tail_header_count);
 
+// Construct a generic SpdyControlFrame.
+spdy::SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
+                                           int extra_header_count,
+                                           bool compressed,
+                                           int stream_id,
+                                           RequestPriority request_priority,
+                                           spdy::SpdyControlType type,
+                                           spdy::SpdyControlFlags flags,
+                                           const char* const* kHeaders,
+                                           int kHeadersSize);
+spdy::SpdyFrame* ConstructSpdyControlFrame(const char* const extra_headers[],
+                                           int extra_header_count,
+                                           bool compressed,
+                                           int stream_id,
+                                           RequestPriority request_priority,
+                                           spdy::SpdyControlType type,
+                                           spdy::SpdyControlFlags flags,
+                                           const char* const* kHeaders,
+                                           int kHeadersSize,
+                                           int associated_stream_id);
+
 // Construct an expected SPDY reply string.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // |buffer| is the buffer we're filling in.
 // Returns the number of bytes written into |buffer|.
 int ConstructSpdyReplyString(const char* const extra_headers[],
                              int extra_header_count,
                              char* buffer,
                              int buffer_length);
 
@@ skipping 40 matching lines @@
 // Constructs a standard SPDY GET SYN packet, optionally compressed.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyGet(const char* const extra_headers[],
                                   int extra_header_count,
                                   bool compressed,
                                   int stream_id,
                                   RequestPriority request_priority);
 
+// Constructs a standard SPDY push SYN packet.
+// |extra_headers| are the extra header-value pairs, which typically
+// will vary the most between calls.
+// Returns a SpdyFrame.
+spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
+                                  int extra_header_count,
+                                  int stream_id,
+                                  int associated_stream_id);
+spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
+                                  int extra_header_count,
+                                  int stream_id,
+                                  int associated_stream_id,
+                                  const char* path);
+spdy::SpdyFrame* ConstructSpdyPush(const char* const extra_headers[],
+                                  int extra_header_count,
+                                  int stream_id,
+                                  int associated_stream_id,
+                                  const char* path,
+                                  const char* status,
+                                  const char* location,
+                                  const char* url);
+
 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyGetSynReply(const char* const extra_headers[],
                                           int extra_header_count,
                                           int stream_id);
 
+// Constructs a standard SPDY SYN_REPLY packet to match the SPDY GET.
+// |extra_headers| are the extra header-value pairs, which typically
+// will vary the most between calls.
+// Returns a SpdyFrame.
+spdy::SpdyFrame* ConstructSpdyGetSynReplyRedirect(int stream_id);
+
+
 // Constructs a standard SPDY POST SYN packet.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // Returns a SpdyFrame.
 spdy::SpdyFrame* ConstructSpdyPost(int64 content_length,
                                    const char* const extra_headers[],
                                    int extra_header_count);
 
 // Constructs a standard SPDY SYN_REPLY packet to match the SPDY POST.
 // |extra_headers| are the extra header-value pairs, which typically
@@ skipping 64 matching lines @@
                                   session_deps->proxy_service,
                                   &session_deps->socket_factory,
                                   session_deps->ssl_config_service,
                                   session_deps->spdy_session_pool,
                                   session_deps->http_auth_handler_factory.get(),
                                   NULL,
                                   NULL);
 }
 };
 
+class SpdyURLRequestContext : public URLRequestContext {
+ public:
+  SpdyURLRequestContext() {
+    host_resolver_ = new MockHostResolver;
+    proxy_service_ = ProxyService::CreateNull();
+    spdy_session_pool_ = new SpdySessionPool();
+    ssl_config_service_ = new SSLConfigServiceDefaults;
+    http_auth_handler_factory_ = HttpAuthHandlerFactory::CreateDefault();
+    http_transaction_factory_ = new net::HttpCache(
+        new HttpNetworkLayer(&socket_factory_,
+                             host_resolver_,
+                             proxy_service_,
+                             ssl_config_service_,
+                             spdy_session_pool_.get(),
+                             http_auth_handler_factory_,
+                             network_delegate_,
+                             NULL),
+        net::HttpCache::DefaultBackend::InMemory(0));
+  }
+
+  MockClientSocketFactory& socket_factory() { return socket_factory_; }
+
+ protected:
+  virtual ~SpdyURLRequestContext() {
+    delete http_transaction_factory_;
+    delete http_auth_handler_factory_;
+  }
+
+ private:
+  MockClientSocketFactory socket_factory_;
+  scoped_refptr<SpdySessionPool> spdy_session_pool_;
+};
+
 // This creates a proxy for testing purposes.
 // |proxy| should be in the form "myproxy:70".
 ProxyService* SpdyCreateFixedProxyService(const std::string& proxy);
 
+const SpdyHeaderInfo make_spdy_header(spdy::SpdyControlType type);
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_H_