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

net/spdy/spdy_session.cc

 // 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.
 
 #include "net/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 220 matching lines @@
 
 SpdyStreamRequest::SpdyStreamRequest() {
   Reset();
 }
 
 SpdyStreamRequest::~SpdyStreamRequest() {
   CancelRequest();
 }
 
 int SpdyStreamRequest::StartRequest(
+    SpdyStreamType type,
     const scoped_refptr<SpdySession>& session,
     const GURL& url,
     RequestPriority priority,
     const BoundNetLog& net_log,
     const CompletionCallback& callback) {
   DCHECK(session);
   DCHECK(!session_);
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
 
+  type_ = type;
   session_ = session;
   url_ = url;
   priority_ = priority;
   net_log_ = net_log;
   callback_ = callback;
 
   base::WeakPtr<SpdyStream> stream;
   int rv = session->TryCreateStream(this, &stream);
   if (rv == OK) {
     Reset();
@@ skipping 32 matching lines @@
   DCHECK(session_);
   DCHECK(!stream_);
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
   Reset();
   DCHECK_NE(rv, OK);
   callback.Run(rv);
 }
 
 void SpdyStreamRequest::Reset() {
+  type_ = SPDY_BIDIRECTIONAL_STREAM;
   session_ = NULL;
   stream_.reset();
   url_ = GURL();
   priority_ = MINIMUM_PRIORITY;
   net_log_ = BoundNetLog();
   callback_.Reset();
 }
 
 SpdySession::SpdySession(const SpdySessionKey& spdy_session_key,
                          SpdySessionPool* spdy_session_pool,
@@ skipping 264 matching lines @@
       CloseSessionOnError(
           ERR_CONNECTION_CLOSED,
           true,
           "Tried to create SPDY stream for a closed socket connection.");
       return ERR_CONNECTION_CLOSED;
     }
   }
 
   const std::string& path = request.url().PathForRequest();
   scoped_ptr<SpdyStream> new_stream(
-      new SpdyStream(this, path, request.priority(),
+      new SpdyStream(request.type(), this, path, request.priority(),
                      stream_initial_send_window_size_,
                      stream_initial_recv_window_size_,
-                     false, request.net_log()));
+                     request.net_log()));
   *stream = new_stream->GetWeakPtr();
   InsertCreatedStream(new_stream.Pass());
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Net.SpdyPriorityCount",
       static_cast<int>(request.priority()), 0, 10, 11);
 
   return OK;
 }
 
@@ skipping 1089 matching lines @@
   }
 
   // There should not be an existing pushed stream with the same path.
   if (unclaimed_pushed_streams_.find(url) != unclaimed_pushed_streams_.end()) {
     ResetStream(stream_id, request_priority, RST_STREAM_PROTOCOL_ERROR,
                 "Received duplicate pushed stream with url: " + url);
     return;
   }
 
   scoped_ptr<SpdyStream> stream(
-      new SpdyStream(this, gurl.PathForRequest(), request_priority,
+      new SpdyStream(SPDY_PUSH_STREAM, this, gurl.PathForRequest(),
+                     request_priority,
                      stream_initial_send_window_size_,
                      stream_initial_recv_window_size_,
-                     true, net_log_));
+                     net_log_));
   stream->set_stream_id(stream_id);
 
   DeleteExpiredPushedStreams();
   unclaimed_pushed_streams_[url] =
       std::pair<SpdyStream*, base::TimeTicks>(stream.get(), time_func_());
 
   stream->set_response_received();
   InsertActivatedStream(stream.Pass());
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
@@ skipping 736 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net