[SPDY] Remove some setters in SpdyStream

net/spdy/spdy_stream.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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/bandwidth_metrics.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_protocol.h"
@@ skipping 80 matching lines @@
   typedef struct {
     FrameType type;
     union {
       SpdyHeaderBlock* header_block;
       SpdyFrame* data_frame;
     };
   } PendingFrame;
 
   // SpdyStream constructor
   SpdyStream(SpdySession* session,
+             const std::string& path,
+             RequestPriority priority,
+             int32 initial_send_window_size,
+             int32 initial_recv_window_size,
              bool pushed,
              const BoundNetLog& net_log);
 
   // Set new |delegate|. |delegate| must not be NULL.
   // If it already received SYN_REPLY or data, OnResponseReceived() or
   // OnDataReceived() will be called.
   void SetDelegate(Delegate* delegate);
   Delegate* GetDelegate() { return delegate_; }
 
   // Detach delegate from the stream. It will cancel the stream if it was not
   // cancelled yet.  It is safe to call multiple times.
   void DetachDelegate();
 
   // Is this stream a pushed stream from the server.
   bool pushed() const { return pushed_; }
 
   SpdyStreamId stream_id() const { return stream_id_; }
   void set_stream_id(SpdyStreamId stream_id) { stream_id_ = stream_id; }
 
   bool response_received() const { return response_received_; }
   void set_response_received() { response_received_ = true; }
 
   // For pushed streams, we track a path to identify them.
   const std::string& path() const { return path_; }
-  void set_path(const std::string& path) { path_ = path; }
 
   RequestPriority priority() const { return priority_; }
-  void set_priority(RequestPriority priority) { priority_ = priority; }

[Ryan Hamilton, 2013/03/24 15:08:40]

Just FYI, with SPDY/4, a stream's priority is mutable.  (via a REPRI flag)

[akalin, 2013/03/24 19:24:53]

I know. :) I'm thinking about how to handle that. I don't like exposing
set_priority() since we only really want the SpdySession to be able to set a
stream's priority (after adjusting all the queues, etc.) and not the delegate.
Maybe I'll move it out of the stream entirely, but I don't know how practical
that is.

[Ryan Hamilton, 2013/03/25 17:07:47]

Heh, I figured you did :>
Interesting.  That seems like a good idea.  Though we have also discussed
allowing the delegate to change the priority of a stream when, for example, we
discover that a higher priority resource needs to be fetched, or if a background
tab becomes foreground.  Perhaps what this says is that the Session needs to
"own" the priority, and if there is a SetPriority method exposed on the stream
that it should merely delegate to the Session's SetStreamPriority method.  (or
something like that)

 
   int32 send_window_size() const { return send_window_size_; }
-  void set_send_window_size(int32 window_size) {
-    send_window_size_ = window_size;
-  }
 
   int32 recv_window_size() const { return recv_window_size_; }
-  void set_recv_window_size(int32 window_size) {
-    recv_window_size_ = window_size;
-  }
 
   bool send_stalled_by_flow_control() { return send_stalled_by_flow_control_; }
 
   void set_send_stalled_by_flow_control(bool stalled) {
     send_stalled_by_flow_control_ = stalled;
   }
 
   // If stream flow control is turned on, called by the session to
   // adjust this stream's send window size by |delta_window_size|,
   // which is the difference between the SETTINGS_INITIAL_WINDOW_SIZE
@@ skipping 194 matching lines @@
   // stream has become stalled on flow control.
   scoped_ptr<SpdyFrame> ProduceNextFrame();
 
   // If the stream is active and stream flow control is turned on,
   // called by OnDataReceived (which is in turn called by the session)
   // to decrease this stream's receive window size by
   // |delta_window_size|, which must be at least 1 and must not cause
   // this stream's receive window size to go negative.
   void DecreaseRecvWindowSize(int32 delta_window_size);
 
+  base::WeakPtrFactory<SpdyStream> weak_ptr_factory_;
+
   // There is a small period of time between when a server pushed stream is
   // first created, and the pushed data is replayed. Any data received during
   // this time should continue to be buffered.
   bool continue_buffering_data_;
 
   SpdyStreamId stream_id_;
-  std::string path_;
-  RequestPriority priority_;
+  const std::string path_;
+  const RequestPriority priority_;
   size_t slot_;
 
   // Flow control variables.
   bool send_stalled_by_flow_control_;
   int32 send_window_size_;
   int32 recv_window_size_;
   int32 unacked_recv_window_bytes_;
 
   const bool pushed_;
   ScopedBandwidthMetrics metrics_;
@@ skipping 46 matching lines @@
   std::string domain_bound_private_key_;
   std::string domain_bound_cert_;
   ServerBoundCertService::RequestHandle domain_bound_cert_request_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_