Move a number of static variables SPDY to HttpNetworkSession::Params.

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 <map>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 159 matching lines @@
                                 NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("last_accepted_stream_id",
                    static_cast<int>(last_stream_id));
   dict->SetInteger("active_streams", active_streams);
   dict->SetInteger("unclaimed_streams", unclaimed_streams);
   dict->SetInteger("status", static_cast<int>(status));
   return dict;
 }
 
-NextProto g_default_protocol = kProtoUnknown;
 // Maximum number of concurrent streams we will create, unless the server
 // sends a SETTINGS frame with a different value.
-size_t g_init_max_concurrent_streams = 100;
+const size_t kInitialMaxConcurrentStreams = 100;
 // The maximum number of concurrent streams we will ever create.  Even if
 // the server permits more, we will never exceed this limit.
-size_t g_max_concurrent_stream_limit = 256;
-size_t g_default_initial_rcv_window_size = 10 * 1024 * 1024;  // 10MB
-bool g_enable_ping_based_connection_checking = true;
-bool g_enable_credential_frames = false;
-
-typedef base::TimeTicks (*ExternalTimeFunc)(void);
-
-static ExternalTimeFunc g_time_func = base::TimeTicks::Now;
+const size_t kMaxConcurrentStreamLimit = 256;
+const size_t kDefaultInitialRecvWindowSize = 10 * 1024 * 1024;  // 10MB
 
 }  // namespace
 
 // static
 void SpdySession::SpdyIOBufferProducer::ActivateStream(
     SpdySession* spdy_session,
     SpdyStream* spdy_stream) {
   spdy_session->ActivateStream(spdy_stream);
 }
 
 // static
 SpdyIOBuffer* SpdySession::SpdyIOBufferProducer::CreateIOBuffer(
     SpdyFrame* frame,
     RequestPriority priority,
     SpdyStream* stream) {
   size_t size = frame->length() + SpdyFrame::kHeaderSize;
   DCHECK_GT(size, 0u);
 
   // TODO(mbelshe): We have too much copying of data here.
   IOBufferWithSize* buffer = new IOBufferWithSize(size);
   memcpy(buffer->data(), frame->data(), size);
 
   return new SpdyIOBuffer(buffer, size, priority, stream);
 }
 
-// static
-void SpdySession::set_default_protocol(NextProto default_protocol) {
-  g_default_protocol = default_protocol;
-}
-
-// static
-void SpdySession::set_max_concurrent_streams(size_t value) {
-  g_max_concurrent_stream_limit = value;
-}
-
-// static
-void SpdySession::set_enable_ping_based_connection_checking(bool enable) {
-  g_enable_ping_based_connection_checking = enable;
-}
-
-// static
-void SpdySession::set_enable_credential_frames(bool enable) {
-  g_enable_credential_frames = enable;
-}
-
-
-// static
-void SpdySession::set_init_max_concurrent_streams(size_t value) {
-  g_init_max_concurrent_streams =
-      std::min(value, g_max_concurrent_stream_limit);
-}
-
-// static
-void SpdySession::set_default_initial_recv_window_size(size_t value) {
-  g_default_initial_rcv_window_size = value;
-}
-
-// static
-void SpdySession::ResetStaticSettingsToInit() {
-  // WARNING: These must match the initializers above.
-  g_default_protocol = kProtoUnknown;
-  g_init_max_concurrent_streams = 100;
-  g_max_concurrent_stream_limit = 256;
-  g_default_initial_rcv_window_size = kSpdyStreamInitialWindowSize;
-  g_enable_ping_based_connection_checking = true;
-  g_enable_credential_frames = false;
-  g_time_func = base::TimeTicks::Now;
-}
-
-// Outside of tests, g_time_func will always be base::TimeTicks::Now.
-// When performing linker optimization for the main executable, the compiler
-// should be able to see that set_time_func() is an uncalled function, that
-// the static .cc variable never changes, and thus that the extra pointer
-// indirection can be removed.
-
-
-
-SpdySession::TimeFunc SpdySession::set_time_func(
-    SpdySession::TimeFunc time_func) {
-  SpdySession::TimeFunc old_time_func =
-      static_cast<SpdySession::TimeFunc>(g_time_func);
-  g_time_func = static_cast<ExternalTimeFunc>(time_func);
-  return old_time_func;
-}
-
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
                          HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          bool enable_sending_initial_settings,
+                         bool enable_credential_frames,
+                         bool enable_compression,
+                         bool enable_ping_based_connection_checking,
+                         NextProto default_protocol,
+                         size_t initial_recv_window_size,
+                         size_t initial_max_concurrent_streams,
+                         size_t max_concurrent_streams_limit,
+                         TimeFunc time_func,
                          const HostPortPair& trusted_spdy_proxy,
                          NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       host_port_proxy_pair_(host_port_proxy_pair),
       spdy_session_pool_(spdy_session_pool),
       http_server_properties_(http_server_properties),
       connection_(new ClientSocketHandle),
       read_buffer_(new IOBuffer(kReadBufferSize)),
       read_pending_(false),
       stream_hi_water_mark_(1),  // Always start at 1 for the first stream id.
       write_pending_(false),
       delayed_write_pending_(false),
       is_secure_(false),
       certificate_error_code_(OK),
       error_(OK),
       state_(IDLE),
-      max_concurrent_streams_(g_init_max_concurrent_streams),
+      max_concurrent_streams_(initial_max_concurrent_streams == 0 ?
+                              kInitialMaxConcurrentStreams :
+                              initial_max_concurrent_streams),
+      max_concurrent_streams_limit_(max_concurrent_streams_limit == 0 ?
+                                    kMaxConcurrentStreamLimit :
+                                    max_concurrent_streams_limit),
       streams_initiated_count_(0),
       streams_pushed_count_(0),
       streams_pushed_and_claimed_count_(0),
       streams_abandoned_count_(0),
       bytes_received_(0),
       sent_settings_(false),
       received_settings_(false),
       stalled_streams_(0),
       pings_in_flight_(0),
       next_ping_id_(1),
       last_activity_time_(base::TimeTicks::Now()),
       check_ping_status_pending_(false),
       flow_control_(false),
       initial_send_window_size_(kSpdyStreamInitialWindowSize),
-      initial_recv_window_size_(g_default_initial_rcv_window_size),
+      initial_recv_window_size_(initial_recv_window_size == 0 ?
+                                kDefaultInitialRecvWindowSize :
+                                initial_recv_window_size),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SPDY_SESSION)),
       verify_domain_authentication_(verify_domain_authentication),
       enable_sending_initial_settings_(enable_sending_initial_settings),
+      enable_credential_frames_(enable_credential_frames),
+      enable_compression_(enable_compression),
+      enable_ping_based_connection_checking_(
+          enable_ping_based_connection_checking),
+      default_protocol_(default_protocol),
       credential_state_(SpdyCredentialState::kDefaultNumSlots),
       connection_at_risk_of_loss_time_(
           base::TimeDelta::FromSeconds(kDefaultConnectionAtRiskOfLossSeconds)),
       hung_interval_(
           base::TimeDelta::FromSeconds(kHungIntervalSeconds)),
-      trusted_spdy_proxy_(trusted_spdy_proxy) {
+      trusted_spdy_proxy_(trusted_spdy_proxy),
+      time_func_(time_func) {
   DCHECK(HttpStreamFactory::spdy_enabled());
   net_log_.BeginEvent(
       NetLog::TYPE_SPDY_SESSION,
       base::Bind(&NetLogSpdySessionCallback, &host_port_proxy_pair_));
-  next_unclaimed_push_stream_sweep_time_ = g_time_func() +
+  next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
   // TODO(mbelshe): consider randomization of the stream_hi_water_mark.
 }
 
 SpdySession::PendingCreateStream::PendingCreateStream(
     const GURL& url, RequestPriority priority,
     scoped_refptr<SpdyStream>* spdy_stream,
     const BoundNetLog& stream_net_log,
     const CompletionCallback& callback)
     : url(&url),
@@ skipping 42 matching lines @@
     bool is_secure,
     int certificate_error_code) {
   base::StatsCounter spdy_sessions("spdy.sessions");
   spdy_sessions.Increment();
 
   state_ = CONNECTED;
   connection_.reset(connection);
   is_secure_ = is_secure;
   certificate_error_code_ = certificate_error_code;
 
-  NextProto protocol = g_default_protocol;
+  NextProto protocol = default_protocol_;
   NextProto protocol_negotiated = connection->socket()->GetNegotiatedProtocol();
   if (protocol_negotiated != kProtoUnknown) {
     protocol = protocol_negotiated;
   }
 
   SSLClientSocket* ssl_socket = GetSSLClientSocket();
   if (ssl_socket && ssl_socket->WasChannelIDSent()) {
     // According to the SPDY spec, the credential associated with the TLS
     // connection is stored in slot[1].
     credential_state_.SetHasCredential(GURL("https://" +
                                             host_port_pair().ToString()));
   }
 
   DCHECK(protocol >= kProtoSPDY2);
   DCHECK(protocol <= kProtoSPDY3);
   int version = (protocol == kProtoSPDY3) ? 3 : 2;
   flow_control_ = (protocol >= kProtoSPDY3);
 
-  buffered_spdy_framer_.reset(new BufferedSpdyFramer(version));
+  buffered_spdy_framer_.reset(new BufferedSpdyFramer(version,
+                                                     enable_compression_));
   buffered_spdy_framer_->set_visitor(this);
   SendInitialSettings();
   UMA_HISTOGRAM_ENUMERATION("Net.SpdyVersion", protocol, kProtoMaximumVersion);
 
   // Write out any data that we might have to send, such as the settings frame.
   WriteSocketLater();
   net::Error error = ReadSocket();
   if (error == ERR_IO_PENDING)
     return OK;
   return error;
 }
 
 bool SpdySession::VerifyDomainAuthentication(const std::string& domain) {
   if (!verify_domain_authentication_)
     return true;
 
   if (state_ != CONNECTED)
     return false;
 
   SSLInfo ssl_info;
   bool was_npn_negotiated;
   NextProto protocol_negotiated = kProtoUnknown;
   if (!GetSSLInfo(&ssl_info, &was_npn_negotiated, &protocol_negotiated))
     return true;   // This is not a secure session, so all domains are okay.
 
   return !ssl_info.client_cert_sent &&
-      (g_enable_credential_frames || !ssl_info.channel_id_sent ||
+      (enable_credential_frames_ || !ssl_info.channel_id_sent ||
        ServerBoundCertService::GetDomainForHost(domain) ==
        ServerBoundCertService::GetDomainForHost(
            host_port_proxy_pair_.first.host())) &&
       ssl_info.cert->VerifyNameMatch(domain);
 }
 
 void SpdySession::SetStreamHasWriteAvailable(SpdyStream* stream,
                                              SpdyIOBufferProducer* producer) {
   write_queue_.push(producer);
   stream_producers_[producer] = stream;
@@ skipping 1015 matching lines @@
   scoped_refptr<SpdyStream> stream(new SpdyStream(this, true, net_log_));
   stream->set_stream_id(stream_id);
 
   stream->set_path(gurl.PathForRequest());
   stream->set_send_window_size(initial_send_window_size_);
   stream->set_recv_window_size(initial_recv_window_size_);
 
   DeleteExpiredPushedStreams();
   unclaimed_pushed_streams_[url] =
       std::pair<scoped_refptr<SpdyStream>, base::TimeTicks> (
-          stream, g_time_func());
+          stream, time_func_());
 
 
   ActivateStream(stream);
   stream->set_response_received();
 
   // Parse the headers.
   if (!Respond(headers, stream))
     return;
 
   base::StatsCounter push_requests("spdy.pushed_streams");
   push_requests.Increment();
 }
 
 void SpdySession::DeleteExpiredPushedStreams() {
   if (unclaimed_pushed_streams_.empty())
     return;
 
   // Check that adequate time has elapsed since the last sweep.
-  if (g_time_func() < next_unclaimed_push_stream_sweep_time_)
+  if (time_func_() < next_unclaimed_push_stream_sweep_time_)
     return;
 
   // Delete old streams.
-  base::TimeTicks minimum_freshness = g_time_func() -
+  base::TimeTicks minimum_freshness = time_func_() -
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
   PushedStreamMap::iterator it;
   for (it = unclaimed_pushed_streams_.begin();
       it != unclaimed_pushed_streams_.end(); ) {
     const scoped_refptr<SpdyStream>& stream = it->second.first;
     base::TimeTicks creation_time = it->second.second;
     // DeleteStream() will invalidate the current iterator, so move to next.
     ++it;
     if (minimum_freshness > creation_time) {
       DeleteStream(stream->stream_id(), ERR_INVALID_SPDY_STREAM);
       base::StatsCounter abandoned_push_streams(
           "spdy.abandoned_push_streams");
       base::StatsCounter abandoned_streams("spdy.abandoned_streams");
       abandoned_push_streams.Increment();
       abandoned_streams.Increment();
       streams_abandoned_count_++;
     }
   }
-  next_unclaimed_push_stream_sweep_time_ = g_time_func() +
+  next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
 }
 
 void SpdySession::OnSynReply(SpdyStreamId stream_id,
                              bool fin,
                              const SpdyHeaderBlock& headers) {
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_REPLY,
         base::Bind(&NetLogSpdySynCallback,
@@ skipping 258 matching lines @@
   scoped_ptr<SpdySettingsControlFrame> settings_frame(
       buffered_spdy_framer_->CreateSettings(settings));
   sent_settings_ = true;
   QueueFrame(settings_frame.release(), HIGHEST);
 }
 
 void SpdySession::HandleSetting(uint32 id, uint32 value) {
   switch (id) {
     case SETTINGS_MAX_CONCURRENT_STREAMS:
       max_concurrent_streams_ = std::min(static_cast<size_t>(value),
-                                         g_max_concurrent_stream_limit);
+                                         kMaxConcurrentStreamLimit);
       ProcessPendingCreateStreams();
       break;
     case SETTINGS_INITIAL_WINDOW_SIZE:
       if (static_cast<int32>(value) < 0) {
         net_log().AddEvent(
             NetLog::TYPE_SPDY_SESSION_NEGATIVE_INITIAL_WINDOW_SIZE,
             NetLog::IntegerCallback("initial_window_size", value));
       } else {
         // SETTINGS_INITIAL_WINDOW_SIZE updates initial_send_window_size_ only.
         int32 delta_window_size = value - initial_send_window_size_;
@@ skipping 16 matching lines @@
   }
 
   CreatedStreamSet::iterator i;
   for (i = created_streams_.begin(); i != created_streams_.end(); i++) {
     const scoped_refptr<SpdyStream>& stream = *i;
     stream->AdjustSendWindowSize(delta_window_size);
   }
 }
 
 void SpdySession::SendPrefacePingIfNoneInFlight() {
-  if (pings_in_flight_ || !g_enable_ping_based_connection_checking)
+  if (pings_in_flight_ || !enable_ping_based_connection_checking_)
     return;
 
   base::TimeTicks now = base::TimeTicks::Now();
   // If there is no activity in the session, then send a preface-PING.
   if ((now - last_activity_time_) > connection_at_risk_of_loss_time_)
     SendPrefacePing();
 }
 
 void SpdySession::SendPrefacePing() {
   WritePingFrame(next_ping_id_);
@@ skipping 159 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net