[SPDY] Add a SpdyStreamType enum and use it for SpdyStream

net/spdy/spdy_session.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_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 14 matching lines @@
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_buffer.h"
 #include "net/spdy/spdy_credential_state.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
+#include "net/spdy/spdy_stream.h"
 #include "net/spdy/spdy_write_queue.h"
 #include "net/ssl/ssl_client_cert_type.h"
 #include "net/ssl/ssl_config_service.h"
 
 namespace net {
 
 // This is somewhat arbitrary and not really fixed, but it will always work
 // reasonably with ethernet. Chop the world into 2-packet chunks.  This is
 // somewhat arbitrary, but is reasonably small and ensures that we elicit
 // ACKs quickly from TCP (because TCP tries to only ACK every other packet).
@@ skipping 77 matching lines @@
   // then when the stream is created, |callback| will be called, at
   // which point ReleaseStream() may be called. Otherwise, the stream
   // is not created, an error is returned, and ReleaseStream() may not
   // be called.
   //
   // If OK is returned, must not be called again without
   // ReleaseStream() being called first. If ERR_IO_PENDING is
   // returned, must not be called again without CancelRequest() or
   // ReleaseStream() being called first. Otherwise, in case of an
   // immediate error, this may be called again.
-  int StartRequest(const scoped_refptr<SpdySession>& session,
+  int StartRequest(SpdyStreamType type,
+                   const scoped_refptr<SpdySession>& session,
                    const GURL& url,
                    RequestPriority priority,
                    const BoundNetLog& net_log,
                    const CompletionCallback& callback);
 
   // Cancels any pending stream creation request. May be called
   // repeatedly.
   void CancelRequest();
 
   // Transfers the created stream (guaranteed to not be NULL) to the
   // caller. Must be called at most once after StartRequest() returns
   // OK or |callback| is called with OK. The caller must immediately
   // set a delegate for the returned stream (except for test code).
   base::WeakPtr<SpdyStream> ReleaseStream();
 
  private:
   friend class SpdySession;
 
   // Called by |session_| when the stream attempt has finished
   // successfully.
   void OnRequestCompleteSuccess(base::WeakPtr<SpdyStream>* stream);
 
   // Called by |session_| when the stream attempt has finished with an
   // error. Also called with ERR_ABORTED if |session_| is destroyed
   // while the stream attempt is still pending.
   void OnRequestCompleteFailure(int rv);
 
   // Accessors called by |session_|.
+  SpdyStreamType type() const { return type_; }
   const GURL& url() const { return url_; }
   RequestPriority priority() const { return priority_; }
   const BoundNetLog& net_log() const { return net_log_; }
 
   void Reset();
 
+  SpdyStreamType type_;
   scoped_refptr<SpdySession> session_;
   base::WeakPtr<SpdyStream> stream_;
   GURL url_;
   RequestPriority priority_;
   BoundNetLog net_log_;
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStreamRequest);
 };
 
@@ skipping 803 matching lines @@
   // This SPDY proxy is allowed to push resources from origins that are
   // different from those of their associated streams.
   HostPortPair trusted_spdy_proxy_;
 
   TimeFunc time_func_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_