Remove many-many SpdyMajorVersion and NextProto arguments and members.

net/tools/flip_server/spdy_interface.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_FLIP_SERVER_SPDY_INTERFACE_H_
 #define NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 16 matching lines @@
 
 class FlipAcceptor;
 class MemoryCache;
 
 class SpdySM : public BufferedSpdyFramerVisitorInterface, public SMInterface {
  public:
   SpdySM(SMConnection* connection,
          SMInterface* sm_http_interface,
          EpollServer* epoll_server,
          MemoryCache* memory_cache,
-         FlipAcceptor* acceptor,
-         SpdyMajorVersion spdy_version);
+         FlipAcceptor* acceptor);
   ~SpdySM() override;
 
   void InitSMInterface(SMInterface* sm_http_interface,
                        int32_t server_idx) override {}
 
   void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                         SMInterface* sm_interface,
                         EpollServer* epoll_server,
                         int fd,
                         std::string server_ip,
                         std::string server_port,
                         std::string remote_ip,
                         bool use_ssl) override;
 
   // Create new SPDY framer after reusing SpdySM and negotiating new version
-  void CreateFramer(SpdyMajorVersion spdy_version);
+  void CreateFramer();
 
  private:
   void set_is_request() override {}
   SMInterface* NewConnectionInterface();
   // virtual for tests
   virtual SMInterface* FindOrMakeNewSMConnectionInterface(
       const std::string& server_ip,
       const std::string& server_port);
   int SpdyHandleNewStream(SpdyStreamId stream_id,
                           SpdyPriority priority,
                           const SpdyHeaderBlock& headers,
                           std::string& http_data,
                           bool* is_https_scheme);
 
   // BufferedSpdyFramerVisitorInterface:
   void OnError(SpdyFramer::SpdyError error_code) override {}
   void OnStreamError(SpdyStreamId stream_id,
                      const std::string& description) override {}
-  // Called after all the header data for SYN_STREAM control frame is received.
-  void OnSynStream(SpdyStreamId stream_id,
-                   SpdyStreamId associated_stream_id,
-                   SpdyPriority priority,
-                   bool fin,
-                   bool unidirectional,
-                   const SpdyHeaderBlock& headers) override;
-
-  // Called after all the header data for SYN_REPLY control frame is received.
-  void OnSynReply(SpdyStreamId stream_id,
-                  bool fin,
-                  const SpdyHeaderBlock& headers) override;
 
   // Called after all the header data for HEADERS control frame is received.
   void OnHeaders(SpdyStreamId stream_id,
                  bool has_priority,
                  int weight,
                  SpdyStreamId parent_stream_id,
                  bool exclusive,
                  bool fin,
                  const SpdyHeaderBlock& headers) override;
 
@@ skipping 89 matching lines @@
   BufferedSpdyFramer* spdy_framer() { return buffered_spdy_framer_.get(); }
 
   const OutputOrdering& output_ordering() const {
     return client_output_ordering_;
   }
 
   static std::string forward_ip_header() { return forward_ip_header_; }
   static void set_forward_ip_header(const std::string& value) {
     forward_ip_header_ = value;
   }
-  SpdyMajorVersion spdy_version() const {
-    DCHECK(buffered_spdy_framer_);
-    return buffered_spdy_framer_->protocol_version();
-  }
 
  private:
   void SendEOFImpl(uint32_t stream_id);
   void SendErrorNotFoundImpl(uint32_t stream_id);
   void KillStream(uint32_t stream_id);
   void CopyHeaders(SpdyHeaderBlock& dest, const BalsaHeaders& headers);
   size_t SendSynStreamImpl(uint32_t stream_id, const BalsaHeaders& headers);
   size_t SendSynReplyImpl(uint32_t stream_id, const BalsaHeaders& headers);
   void SendDataFrameImpl(uint32_t stream_id,
                          const char* data,
@@ skipping 21 matching lines @@
   typedef std::map<uint32_t, SMInterface*> StreamToSmif;
   StreamToSmif stream_to_smif_;
   bool close_on_error_;
 
   static std::string forward_ip_header_;
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_