Initial fuzzer for SpdySession

net/spdy/spdy_test_util_common.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 #define NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 164 matching lines @@
   // Default set of dependencies -- "null" proxy service.
   SpdySessionDependencies();
 
   // Custom proxy service dependency.
   explicit SpdySessionDependencies(std::unique_ptr<ProxyService> proxy_service);
 
   ~SpdySessionDependencies();
 
   static std::unique_ptr<HttpNetworkSession> SpdyCreateSession(
       SpdySessionDependencies* session_deps);
+
+  // Variant that ignores session_deps->socket_factory, and uses the passed in
+  // |factory| instead.
+  static std::unique_ptr<HttpNetworkSession> SpdyCreateSessionWithSocketFactory(
+      SpdySessionDependencies* session_deps,
+      ClientSocketFactory* factory);
   static HttpNetworkSession::Params CreateSessionParams(
       SpdySessionDependencies* session_deps);
 
   // NOTE: host_resolver must be ordered before http_auth_handler_factory.
   std::unique_ptr<MockHostResolverBase> host_resolver;
   std::unique_ptr<CertVerifier> cert_verifier;
   std::unique_ptr<ChannelIDService> channel_id_service;
   std::unique_ptr<TransportSecurityState> transport_security_state;
   std::unique_ptr<CTVerifier> cert_transparency_verifier;
   std::unique_ptr<CTPolicyEnforcer> ct_policy_enforcer;
@@ skipping 88 matching lines @@
 
 class SpdyTestUtil {
  public:
   SpdyTestUtil();
   ~SpdyTestUtil();
 
   // Add the appropriate headers to put |url| into |block|.
   void AddUrlToHeaderBlock(base::StringPiece url,
                            SpdyHeaderBlock* headers) const;
 
-  SpdyHeaderBlock ConstructGetHeaderBlock(base::StringPiece url) const;
-  SpdyHeaderBlock ConstructGetHeaderBlockForProxy(base::StringPiece url) const;
-  SpdyHeaderBlock ConstructHeadHeaderBlock(base::StringPiece url,
-                                           int64_t content_length) const;
-  SpdyHeaderBlock ConstructPostHeaderBlock(base::StringPiece url,
-                                           int64_t content_length) const;
-  SpdyHeaderBlock ConstructPutHeaderBlock(base::StringPiece url,
-                                          int64_t content_length) const;
+  static SpdyHeaderBlock ConstructGetHeaderBlock(base::StringPiece url);
+  static SpdyHeaderBlock ConstructGetHeaderBlockForProxy(base::StringPiece url);
+  static SpdyHeaderBlock ConstructHeadHeaderBlock(base::StringPiece url,
+                                                  int64_t content_length);
+  static SpdyHeaderBlock ConstructPostHeaderBlock(base::StringPiece url,
+                                                  int64_t content_length);
+  static SpdyHeaderBlock ConstructPutHeaderBlock(base::StringPiece url,
+                                                 int64_t content_length);
 
   // Construct an expected SPDY reply string from the given headers.
   std::string ConstructSpdyReplyString(const SpdyHeaderBlock& headers) const;
 
   // Construct an expected SPDY SETTINGS frame.
   // |settings| are the settings to set.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdySerializedFrame ConstructSpdySettings(const SettingsMap& settings);
 
   // Constructs an expected SPDY SETTINGS acknowledgement frame.
@@ skipping 182 matching lines @@
   // Serialize a SpdyFrameIR with |headerless_spdy_framer_|.
   SpdySerializedFrame SerializeFrame(const SpdyFrameIR& frame_ir);
 
   // Called when necessary (when it will affect stream dependency specification
   // when setting dependencies based on priorioties) to notify the utility
   // class of stream destruction.
   void UpdateWithStreamDestruction(int stream_id);
 
   void set_default_url(const GURL& url) { default_url_ = url; }
 
-  const char* GetMethodKey() const;
-  const char* GetStatusKey() const;
-  const char* GetHostKey() const;
-  const char* GetSchemeKey() const;
-  const char* GetPathKey() const;
+  static const char* GetMethodKey();
+  static const char* GetStatusKey();
+  static const char* GetHostKey();
+  static const char* GetSchemeKey();
+  static const char* GetPathKey();
 
  private:
   // |content_length| may be NULL, in which case the content-length
   // header will be omitted.
-  SpdyHeaderBlock ConstructHeaderBlock(base::StringPiece method,
-                                       base::StringPiece url,
-                                       int64_t* content_length) const;
+  static SpdyHeaderBlock ConstructHeaderBlock(base::StringPiece method,
+                                              base::StringPiece url,
+                                              int64_t* content_length);
 
   // Multiple SpdyFramers are required to keep track of header compression
   // state.
   // Use to serialize frames (request or response) without headers.
   SpdyFramer headerless_spdy_framer_;
   // Use to serialize request frames with headers.
   SpdyFramer request_spdy_framer_;
   // Use to serialize response frames with headers.
   SpdyFramer response_spdy_framer_;
 
   GURL default_url_;
 
   // Track a FIFO list of the stream_id of all created requests by priority.
   std::map<int, std::vector<int>> priority_to_stream_id_list_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_COMMON_H_