Persist dynamically learned SPDY settings (like CWND).

net/spdy/spdy_session.cc

 // Copyright (c) 2011 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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/stats_counters.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
+#include "net/http/http_server_properties.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_settings_storage.h"
 #include "net/spdy/spdy_stream.h"
 
 namespace net {
 
@@ skipping 203 matching lines @@
 int SpdySession::connection_at_risk_of_loss_ms_ = 0;
 
 // static
 int SpdySession::trailing_ping_delay_time_ms_ = 1000;
 
 // static
 int SpdySession::hung_interval_ms_ = 10000;
 
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
-                         SpdySettingsStorage* spdy_settings,
+                         HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &SpdySession::OnReadComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           write_callback_(this, &SpdySession::OnWriteComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       host_port_proxy_pair_(host_port_proxy_pair),
       spdy_session_pool_(spdy_session_pool),
-      spdy_settings_(spdy_settings),
+      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),
@@ skipping 1125 matching lines @@
   if (!need_to_send_ping_)
     return;
 
   PlanToSendTrailingPing();
 }
 
 void SpdySession::OnSettings(const spdy::SpdySettingsControlFrame& frame) {
   spdy::SpdySettings settings;
   if (spdy_framer_.ParseSettings(&frame, &settings)) {
     HandleSettings(settings);
-    spdy_settings_->Set(host_port_pair(), settings);
+    http_server_properties_->SetSpdySettings(host_port_pair(), settings);
   }
 
   received_settings_ = true;
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_RECV_SETTINGS,
       make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
 }
 
 void SpdySession::OnWindowUpdate(
@@ skipping 60 matching lines @@
   else if (trial->group_name() == "cwndDynamic")
     return cwnd;
   NOTREACHED();
   return cwnd;
 }
 
 void SpdySession::SendSettings() {
   // Note:  we're copying the settings here, so that we can potentially modify
   // the settings for the field trial.  When removing the field trial, make
   // this a reference to the const SpdySettings again.
-  spdy::SpdySettings settings = spdy_settings_->Get(host_port_pair());
+  spdy::SpdySettings settings =
+      http_server_properties_->GetSpdySettings(host_port_pair());
   if (settings.empty())
     return;
 
   // Record Histogram Data and Apply the SpdyCwnd FieldTrial if applicable.
   for (spdy::SpdySettings::iterator i = settings.begin(),
            end = settings.end(); i != end; ++i) {
     const uint32 id = i->first.id();
     const uint32 val = i->second;
     switch (id) {
       case spdy::SETTINGS_CURRENT_CWND:
         uint32 cwnd = 0;
         cwnd = ApplyCwndFieldTrialPolicy(val);
         UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsCwndSent",
                                     cwnd,
                                     1, 200, 100);
         if (cwnd != val) {
           i->second = cwnd;
           i->first.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-          spdy_settings_->Set(host_port_pair(), settings);
+          http_server_properties_->SetSpdySettings(host_port_pair(), settings);
         }
         break;
     }
   }
 
   HandleSettings(settings);
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
       make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
@@ skipping 143 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Net.SpdySettingsReceived",
                             received_settings_ ? 1 : 0, 2);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdyStreamStallsPerSession",
                               stalled_streams_,
                               0, 300, 50);
   UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionsWithStalls",
                             stalled_streams_ > 0 ? 1 : 0, 2);
 
   if (received_settings_) {
     // Enumerate the saved settings, and set histograms for it.
-    const spdy::SpdySettings& settings = spdy_settings_->Get(host_port_pair());
+    const spdy::SpdySettings& settings =
+        http_server_properties_->GetSpdySettings(host_port_pair());
 
     spdy::SpdySettings::const_iterator it;
     for (it = settings.begin(); it != settings.end(); ++it) {
       const spdy::SpdySetting setting = *it;
       switch (setting.first.id()) {
         case spdy::SETTINGS_CURRENT_CWND:
           // Record several different histograms to see if cwnd converges
           // for larger volumes of data being sent.
           UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsCwnd",
                                       setting.second,
@@ skipping 42 matching lines @@
   if (it == pending_callback_map_.end())
     return;
 
   OldCompletionCallback* callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
   callback->Run(result);
 }
 
 }  // namespace net