Clang format slam.

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 94 matching lines @@
   PROTOCOL_ERROR_RST_STREAM_FOR_NON_ACTIVE_STREAM = 23,
   PROTOCOL_ERROR_SPDY_COMPRESSION_FAILURE = 24,
   PROTOCOL_ERROR_REQUEST_FOR_SECURE_CONTENT_OVER_INSECURE_SESSION = 25,
   PROTOCOL_ERROR_SYN_REPLY_NOT_RECEIVED = 26,
   PROTOCOL_ERROR_INVALID_WINDOW_UPDATE_SIZE = 27,
   PROTOCOL_ERROR_RECEIVE_WINDOW_VIOLATION = 28,
 
   // Next free value.
   NUM_SPDY_PROTOCOL_ERROR_DETAILS = 35,
 };
-SpdyProtocolErrorDetails NET_EXPORT_PRIVATE MapFramerErrorToProtocolError(
-    SpdyFramer::SpdyError);
-SpdyProtocolErrorDetails NET_EXPORT_PRIVATE MapRstStreamStatusToProtocolError(
-    SpdyRstStreamStatus);
+SpdyProtocolErrorDetails NET_EXPORT_PRIVATE
+    MapFramerErrorToProtocolError(SpdyFramer::SpdyError);
+SpdyProtocolErrorDetails NET_EXPORT_PRIVATE
+    MapRstStreamStatusToProtocolError(SpdyRstStreamStatus);
 
 // If these compile asserts fail then SpdyProtocolErrorDetails needs
 // to be updated with new values, as do the mapping functions above.
 COMPILE_ASSERT(12 == SpdyFramer::LAST_ERROR,
                SpdyProtocolErrorDetails_SpdyErrors_mismatch);
 COMPILE_ASSERT(15 == RST_STREAM_NUM_STATUS_CODES,
                SpdyProtocolErrorDetails_RstStreamStatus_mismatch);
 
 // A helper class used to manage a request to create a stream.
 class NET_EXPORT_PRIVATE SpdyStreamRequest {
@@ skipping 97 matching lines @@
               NetLog* net_log);
 
   virtual ~SpdySession();
 
   const HostPortPair& host_port_pair() const {
     return spdy_session_key_.host_port_proxy_pair().first;
   }
   const HostPortProxyPair& host_port_proxy_pair() const {
     return spdy_session_key_.host_port_proxy_pair();
   }
-  const SpdySessionKey& spdy_session_key() const {
-    return spdy_session_key_;
-  }
+  const SpdySessionKey& spdy_session_key() const { return spdy_session_key_; }
   // Get a pushed stream for a given |url|.  If the server initiates a
   // stream, it might already exist for a given path.  The server
   // might also not have initiated the stream yet, but indicated it
   // will via X-Associated-Content.  Returns OK if a stream was found
   // and put into |spdy_stream|, or if one was not found but it is
   // okay to create a new stream (in which case |spdy_stream| is
   // reset).  Returns an error (not ERR_IO_PENDING) otherwise, and
   // resets |spdy_stream|.
-  int GetPushStream(
-      const GURL& url,
-      base::WeakPtr<SpdyStream>* spdy_stream,
-      const BoundNetLog& stream_net_log);
+  int GetPushStream(const GURL& url,
+                    base::WeakPtr<SpdyStream>* spdy_stream,
+                    const BoundNetLog& stream_net_log);
 
   // Initialize the session with the given connection. |is_secure|
   // must indicate whether |connection| uses an SSL socket or not; it
   // is usually true, but it can be false for testing or when SPDY is
   // configured to work with non-secure sockets.
   //
   // |pool| is the SpdySessionPool that owns us.  Its lifetime must
   // strictly be greater than |this|.
   //
   // |certificate_error_code| must either be OK or less than
@@ skipping 24 matching lines @@
   bool VerifyDomainAuthentication(const std::string& domain);
 
   // Pushes the given producer into the write queue for
   // |stream|. |stream| is guaranteed to be activated before the
   // producer is used to produce its frame.
   void EnqueueStreamWrite(const base::WeakPtr<SpdyStream>& stream,
                           SpdyFrameType frame_type,
                           scoped_ptr<SpdyBufferProducer> producer);
 
   // Creates and returns a SYN frame for |stream_id|.
-  scoped_ptr<SpdyFrame> CreateSynStream(
-      SpdyStreamId stream_id,
-      RequestPriority priority,
-      SpdyControlFlags flags,
-      const SpdyHeaderBlock& headers);
+  scoped_ptr<SpdyFrame> CreateSynStream(SpdyStreamId stream_id,
+                                        RequestPriority priority,
+                                        SpdyControlFlags flags,
+                                        const SpdyHeaderBlock& headers);
 
   // Creates and returns a SpdyBuffer holding a data frame with the
   // given data. May return NULL if stalled by flow control.
   scoped_ptr<SpdyBuffer> CreateDataBuffer(SpdyStreamId stream_id,
                                           IOBuffer* data,
                                           int len,
                                           SpdyDataFlags flags);
 
   // Close the stream with the given ID, which must exist and be
   // active. Note that that stream may hold the last reference to the
@@ skipping 23 matching lines @@
   bool GetSSLInfo(SSLInfo* ssl_info,
                   bool* was_npn_negotiated,
                   NextProto* protocol_negotiated);
 
   // Fills SSL Certificate Request info |cert_request_info| and returns
   // true when SSL is in use.
   bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
 
   // Send a WINDOW_UPDATE frame for a stream. Called by a stream
   // whenever receive window size is increased.
-  void SendStreamWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size);
+  void SendStreamWindowUpdate(SpdyStreamId stream_id, uint32 delta_window_size);
 
   // Whether the stream is closed, i.e. it has stopped processing data
   // and is about to be destroyed.
   //
   // TODO(akalin): This is only used in tests. Remove this function
   // and have tests test the WeakPtr instead.
   bool IsClosed() const { return availability_state_ == STATE_CLOSED; }
 
   // Closes this session. This will close all active streams and mark
   // the session as permanently closed. Callers must assume that the
@@ skipping 15 matching lines @@
   // Value.  Caller takes possession of the returned value.
   base::Value* GetInfoAsValue() const;
 
   // Indicates whether the session is being reused after having successfully
   // used to send/receive data in the past or if the underlying socket was idle
   // before being used for a SPDY session.
   bool IsReused() const;
 
   // Returns true if the underlying transport socket ever had any reads or
   // writes.
-  bool WasEverUsed() const {
-    return connection_->socket()->WasEverUsed();
-  }
+  bool WasEverUsed() const { return connection_->socket()->WasEverUsed(); }
 
   // Returns the load timing information from the perspective of the given
   // stream.  If it's not the first stream, the connection is considered reused
   // for that stream.
   //
   // This uses a different notion of reuse than IsReused().  This function
   // sets |socket_reused| to false only if |stream_id| is the ID of the first
   // stream using the session.  IsReused(), on the other hand, indicates if the
   // session has been used to send/receive data at all.
   bool GetLoadTimingInfo(SpdyStreamId stream_id,
                          LoadTimingInfo* load_timing_info) const;
 
   // Returns true if session is not currently active
   bool is_active() const {
     return !active_streams_.empty() || !created_streams_.empty();
   }
 
   // Access to the number of active and pending streams.  These are primarily
   // available for testing and diagnostics.
   size_t num_active_streams() const { return active_streams_.size(); }
   size_t num_unclaimed_pushed_streams() const {
-      return unclaimed_pushed_streams_.size();
+    return unclaimed_pushed_streams_.size();
   }
   size_t num_created_streams() const { return created_streams_.size(); }
 
   size_t pending_create_stream_queue_size(RequestPriority priority) const {
     DCHECK_GE(priority, MINIMUM_PRIORITY);
     DCHECK_LE(priority, MAXIMUM_PRIORITY);
     return pending_create_stream_queues_[priority].size();
   }
 
   // Returns the (version-dependent) flow control state.
-  FlowControlState flow_control_state() const {
-    return flow_control_state_;
-  }
+  FlowControlState flow_control_state() const { return flow_control_state_; }
 
   // Returns the current |stream_initial_send_window_size_|.
   int32 stream_initial_send_window_size() const {
     return stream_initial_send_window_size_;
   }
 
   // Returns the current |stream_initial_recv_window_size_|.
   int32 stream_initial_recv_window_size() const {
     return stream_initial_recv_window_size_;
   }
 
   // Returns true if no stream in the session can send data due to
   // session flow control.
   bool IsSendStalled() const {
-    return
-        flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION &&
-        session_send_window_size_ == 0;
+    return flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION &&
+           session_send_window_size_ == 0;
   }
 
   const BoundNetLog& net_log() const { return net_log_; }
 
   int GetPeerAddress(IPEndPoint* address) const;
   int GetLocalAddress(IPEndPoint* address) const;
 
   // Adds |alias| to set of aliases associated with this session.
   void AddPooledAlias(const SpdySessionKey& alias_key);
 
@@ skipping 217 matching lines @@
   // Adjust the send window size of all ActiveStreams and PendingStreamRequests.
   void UpdateStreamsSendWindowSize(int32 delta_window_size);
 
   // Send the PING (preface-PING) frame.
   void SendPrefacePingIfNoneInFlight();
 
   // Send PING if there are no PINGs in flight and we haven't heard from server.
   void SendPrefacePing();
 
   // Send a single WINDOW_UPDATE frame.
-  void SendWindowUpdateFrame(SpdyStreamId stream_id, uint32 delta_window_size,
+  void SendWindowUpdateFrame(SpdyStreamId stream_id,
+                             uint32 delta_window_size,
                              RequestPriority priority);
 
   // Send the PING frame.
   void WritePingFrame(uint32 unique_id, bool is_ack);
 
   // Post a CheckPingStatus call after delay. Don't post if there is already
   // CheckPingStatus running.
   void PlanToCheckPingStatus();
 
   // Check the status of the connection. It calls |CloseSessionOnError| if we
@@ skipping 112 matching lines @@
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
                         SpdyGoAwayStatus status) OVERRIDE;
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
                                  bool fin) OVERRIDE;
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
                                  bool fin) OVERRIDE;
   virtual void OnSettings(bool clear_persisted) OVERRIDE;
-  virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE;
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
                               uint32 delta_window_size) OVERRIDE;
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id) OVERRIDE;
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional,
                            const SpdyHeaderBlock& headers) OVERRIDE;
-  virtual void OnSynReply(
-      SpdyStreamId stream_id,
-      bool fin,
-      const SpdyHeaderBlock& headers) OVERRIDE;
-  virtual void OnHeaders(
-      SpdyStreamId stream_id,
-      bool fin,
-      const SpdyHeaderBlock& headers) OVERRIDE;
+  virtual void OnSynReply(SpdyStreamId stream_id,
+                          bool fin,
+                          const SpdyHeaderBlock& headers) OVERRIDE;
+  virtual void OnHeaders(SpdyStreamId stream_id,
+                         bool fin,
+                         const SpdyHeaderBlock& headers) OVERRIDE;
 
   // SpdyFramerDebugVisitorInterface
-  virtual void OnSendCompressedFrame(
-      SpdyStreamId stream_id,
-      SpdyFrameType type,
-      size_t payload_len,
-      size_t frame_len) OVERRIDE;
-  virtual void OnReceiveCompressedFrame(
-      SpdyStreamId stream_id,
-      SpdyFrameType type,
-      size_t frame_len) OVERRIDE;
+  virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
+                                     SpdyFrameType type,
+                                     size_t payload_len,
+                                     size_t frame_len) OVERRIDE;
+  virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
+                                        SpdyFrameType type,
+                                        size_t frame_len) OVERRIDE;
 
   // Called when bytes are consumed from a SpdyBuffer for a DATA frame
   // that is to be written or is being written. Increases the send
   // window size accordingly if some or all of the SpdyBuffer is being
   // discarded.
   //
   // If session flow control is turned off, this must not be called.
   void OnWriteBufferConsumed(size_t frame_payload_size,
                              size_t consume_size,
                              SpdyBuffer::ConsumeSource consume_source);
@@ skipping 278 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_