Initial fuzzer for SpdySession

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 2013 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/spdy/spdy_test_util_common.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <utility>
@@ skipping 345 matching lines @@
   // cancellable TCPConnectJobs, use synchronous lookups.
   host_resolver->set_synchronous_mode(true);
   http2_settings[SETTINGS_INITIAL_WINDOW_SIZE] = kDefaultInitialWindowSize;
 }
 
 SpdySessionDependencies::~SpdySessionDependencies() {}
 
 // static
 std::unique_ptr<HttpNetworkSession> SpdySessionDependencies::SpdyCreateSession(
     SpdySessionDependencies* session_deps) {
+  return SpdyCreateSessionWithSocketFactory(session_deps,
+                                            session_deps->socket_factory.get());
+}
+
+// static
+std::unique_ptr<HttpNetworkSession>
+SpdySessionDependencies::SpdyCreateSessionWithSocketFactory(
+    SpdySessionDependencies* session_deps,
+    ClientSocketFactory* factory) {
   HttpNetworkSession::Params params = CreateSessionParams(session_deps);
-  params.client_socket_factory = session_deps->socket_factory.get();
+  params.client_socket_factory = factory;
   std::unique_ptr<HttpNetworkSession> http_session(
       new HttpNetworkSession(params));
   SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
   pool_peer.SetEnableSendingInitialData(false);
   return http_session;
 }
 
 // static
 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
     SpdySessionDependencies* session_deps) {
@@ skipping 298 matching lines @@
 
 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
                                        SpdyHeaderBlock* headers) const {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   (*headers)[GetHostKey()] = host;
   (*headers)[GetSchemeKey()] = scheme;
   (*headers)[GetPathKey()] = path;
 }
 
-SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlock(
-    base::StringPiece url) const {
+// static
+SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlock(base::StringPiece url) {
   return ConstructHeaderBlock("GET", url, NULL);
 }
 
+// static
 SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlockForProxy(
-    base::StringPiece url) const {
+    base::StringPiece url) {
   return ConstructGetHeaderBlock(url);
 }
 
-SpdyHeaderBlock SpdyTestUtil::ConstructHeadHeaderBlock(
-    base::StringPiece url,
-    int64_t content_length) const {
+// static
+SpdyHeaderBlock SpdyTestUtil::ConstructHeadHeaderBlock(base::StringPiece url,
+                                                       int64_t content_length) {
   return ConstructHeaderBlock("HEAD", url, nullptr);
 }
 
-SpdyHeaderBlock SpdyTestUtil::ConstructPostHeaderBlock(
-    base::StringPiece url,
-    int64_t content_length) const {
+// static
+SpdyHeaderBlock SpdyTestUtil::ConstructPostHeaderBlock(base::StringPiece url,
+                                                       int64_t content_length) {
   return ConstructHeaderBlock("POST", url, &content_length);
 }
 
-SpdyHeaderBlock SpdyTestUtil::ConstructPutHeaderBlock(
-    base::StringPiece url,
-    int64_t content_length) const {
+// static
+SpdyHeaderBlock SpdyTestUtil::ConstructPutHeaderBlock(base::StringPiece url,
+                                                      int64_t content_length) {
   return ConstructHeaderBlock("PUT", url, &content_length);
 }
 
 std::string SpdyTestUtil::ConstructSpdyReplyString(
     const SpdyHeaderBlock& headers) const {
   std::string reply_string;
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
        it != headers.end(); ++it) {
     std::string key = it->first.as_string();
     // Remove leading colon from pseudo headers.
@@ skipping 366 matching lines @@
          stream_it != priority_it->second.end(); ++stream_it) {
       if (*stream_it == stream_id) {
         priority_it->second.erase(stream_it);
         return;
       }
     }
   }
   NOTREACHED();
 }
 
-const char* SpdyTestUtil::GetMethodKey() const {
+// static
+const char* SpdyTestUtil::GetMethodKey() {
   return ":method";
 }
 
-const char* SpdyTestUtil::GetStatusKey() const {
+// static
+const char* SpdyTestUtil::GetStatusKey() {
   return ":status";
 }
 
-const char* SpdyTestUtil::GetHostKey() const {
+// static
+const char* SpdyTestUtil::GetHostKey() {
   return ":authority";
 }
 
-const char* SpdyTestUtil::GetSchemeKey() const {
+// static
+const char* SpdyTestUtil::GetSchemeKey() {
   return ":scheme";
 }
 
-const char* SpdyTestUtil::GetPathKey() const {
+// static
+const char* SpdyTestUtil::GetPathKey() {
   return ":path";
 }
 
-SpdyHeaderBlock SpdyTestUtil::ConstructHeaderBlock(
-    base::StringPiece method,
-    base::StringPiece url,
-    int64_t* content_length) const {
+// static
+SpdyHeaderBlock SpdyTestUtil::ConstructHeaderBlock(base::StringPiece method,
+                                                   base::StringPiece url,
+                                                   int64_t* content_length) {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   SpdyHeaderBlock headers;
   headers[GetMethodKey()] = method.as_string();
   headers[GetHostKey()] = host.c_str();
   headers[GetSchemeKey()] = scheme.c_str();
   headers[GetPathKey()] = path.c_str();
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
     headers["content-length"] = length_str;
   }
   return headers;
 }
 
 }  // namespace net