SPDY - integration of spdy/3 code.

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/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 "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
 #include "crypto/signature_creator.h"
 #include "net/base/asn1_util.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/origin_bound_cert_service.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 {
 
 NetLogSpdySynParameter::NetLogSpdySynParameter(
@@ skipping 222 matching lines @@
 
 }  // namespace
 
 // static
 bool SpdySession::use_ssl_ = true;
 
 // static
 SpdySession::FlowControl SpdySession::use_flow_control_ =
     SpdySession::kFlowControlBasedOnNPN;
 
+SSLClientSocket::NextProto SpdySession::default_protocol_ =
+    SSLClientSocket::kProtoUnknown;
+
 // static
 size_t SpdySession::init_max_concurrent_streams_ = 10;
 
 // static
 size_t SpdySession::max_concurrent_stream_limit_ = 256;
 
 // static
 bool SpdySession::enable_ping_based_connection_checking_ = true;
 
 // static
 int SpdySession::connection_at_risk_of_loss_seconds_ = 10;
 
 // static
 int SpdySession::trailing_ping_delay_time_ms_ = 1000;  // 1 second
 
 // static
 int SpdySession::hung_interval_ms_ = 10000;  // 10 seconds
 
+// static
+void SpdySession::ResetStaticSettingsToInit() {
+  // WARNING: These must match the initializers above.
+  use_flow_control_ = SpdySession::kFlowControlBasedOnNPN;
+  default_protocol_ = SSLClientSocket::kProtoUnknown;
+}
+
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
                          HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          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),
@@ skipping 73 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;
 
+  SSLClientSocket::NextProto protocol = default_protocol_;
   if (is_secure_) {
     SSLClientSocket* ssl_socket = GetSSLClientSocket();
 
     SSLClientSocket::NextProto protocol_negotiated =
         ssl_socket->protocol_negotiated();
-    if (protocol_negotiated != SSLClientSocket::kProtoUnknown)
+    if (protocol_negotiated != SSLClientSocket::kProtoUnknown) {
+      protocol = protocol_negotiated;
       flow_control_ = (protocol_negotiated >= SSLClientSocket::kProtoSPDY21);
+    }
 
     if (ssl_socket->WasOriginBoundCertSent()) {
       // According to the SPDY spec, the credential associated with the TLS
       // connection is stored in slot[0].
       credential_state_.SetHasCredential(host_port_pair());
     }
   }
 
-  buffered_spdy_framer_.reset(new spdy::BufferedSpdyFramer(2));
+  int version = 2;
+  switch (protocol) {
+    case SSLClientSocket::kProtoSPDY2:
+    case SSLClientSocket::kProtoSPDY21:
+      version = 2;
+      break;
+    case SSLClientSocket::kProtoSPDY3:
+      version = 3;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+
+  buffered_spdy_framer_.reset(new spdy::BufferedSpdyFramer(version));
   buffered_spdy_framer_->set_visitor(this);
   SendSettings();
 
   // 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;
 }
@@ skipping 857 matching lines @@
 
   if (!IsStreamActive(stream_id)) {
     // NOTE:  it may just be that the stream was cancelled.
     return;
   }
 
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   stream->OnDataReceived(data, len);
 }
 
+void SpdySession::OnSetting(spdy::SpdySettingsIds id,
+                            uint8 flags,
+                            uint32 value) {
+  HandleSetting(id, value);
+  spdy::SettingsFlagsAndId flags_and_id(flags, id);
+  http_server_properties_->SetSpdySetting(
+      host_port_pair(), std::make_pair(flags_and_id, value));
+
+  received_settings_ = true;
+
+  // Log the settings.
+  spdy::SpdySettings settings;
+  settings.insert(settings.end(), std::make_pair(flags_and_id, value));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_SESSION_RECV_SETTINGS,
+      make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
+}
+
 bool SpdySession::Respond(const spdy::SpdyHeaderBlock& headers,
                           const scoped_refptr<SpdyStream> stream) {
   int rv = OK;
   rv = stream->OnResponseReceived(headers);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     const spdy::SpdyStreamId stream_id = stream->stream_id();
     DeleteStream(stream_id, rv);
     return false;
   }
@@ skipping 241 matching lines @@
   // We will record RTT in histogram when there are no more client sent
   // pings_in_flight_.
   RecordPingRTTHistogram(base::TimeTicks::Now() - last_ping_sent_time_);
 
   if (!need_to_send_ping_)
     return;
 
   PlanToSendTrailingPing();
 }
 
-void SpdySession::OnSettings(const spdy::SpdySettingsControlFrame& frame) {
-  spdy::SpdySettings settings;
-  if (spdy::SpdyFramer::ParseSettings(&frame, &settings)) {
-    HandleSettings(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(
     const spdy::SpdyWindowUpdateControlFrame& frame) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
   int32 delta_window_size = static_cast<int32>(frame.delta_window_size());
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_RECEIVED_WINDOW_UPDATE,
       make_scoped_refptr(new NetLogSpdyWindowUpdateParameter(
           stream_id, delta_window_size)));
 
   if (!IsStreamActive(stream_id)) {
@@ skipping 58 matching lines @@
 
 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 =
       http_server_properties_->GetSpdySettings(host_port_pair());
   if (settings.empty())
     return;
 
+  typedef std::map<uint32, spdy::SpdySetting> SpdySettingsMap;
+  SpdySettingsMap unique_settings;
+
   // 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) {
+          spdy::SettingsFlagsAndId new_id(spdy::SETTINGS_FLAG_PLEASE_PERSIST,
+                                          id);
           i->second = cwnd;
-          i->first.set_flags(spdy::SETTINGS_FLAG_PLEASE_PERSIST);
-          http_server_properties_->SetSpdySettings(host_port_pair(), settings);
+          i->first = new_id;
+          spdy::SpdySetting setting(new_id, val);
+          http_server_properties_->SetSpdySetting(host_port_pair(), setting);
+          unique_settings[id] = setting;
+          continue;
         }
-        break;
     }
+    unique_settings[id] = *i;
   }
 
   HandleSettings(settings);
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
       make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
 
+  spdy::SpdySettings sorted_settings;
+  for (SpdySettingsMap::iterator it = unique_settings.begin();
+       unique_settings.end() != it;
+       ++it) {
+    sorted_settings.push_back(it->second);
+  }
+
   // Create the SETTINGS frame and send it.
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<spdy::SpdySettingsControlFrame> settings_frame(
-      buffered_spdy_framer_->CreateSettings(settings));
+      buffered_spdy_framer_->CreateSettings(sorted_settings));
   sent_settings_ = true;
   QueueFrame(settings_frame.get(), 0, NULL);
 }
 
 void SpdySession::HandleSettings(const spdy::SpdySettings& settings) {
   for (spdy::SpdySettings::const_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_MAX_CONCURRENT_STREAMS:
-        max_concurrent_streams_ = std::min(static_cast<size_t>(val),
-                                           max_concurrent_stream_limit_);
-        ProcessPendingCreateStreams();
-        break;
-      case spdy::SETTINGS_INITIAL_WINDOW_SIZE:
-        // INITIAL_WINDOW_SIZE updates initial_send_window_size_ only.
-        // TODO(rtenneti): discuss with the server team about
-        // initial_recv_window_size_.
-        int32 prev_initial_send_window_size = initial_send_window_size_;
-        initial_send_window_size_ = val;
-        int32 delta_window_size =
-            initial_send_window_size_ - prev_initial_send_window_size;
-        UpdateStreamsSendWindowSize(delta_window_size);
-        break;
-    }
+    HandleSetting(i->first.id(), i->second);
+  }
+}
+
+void SpdySession::HandleSetting(uint32 id, uint32 value) {
+  switch (id) {
+    case spdy::SETTINGS_MAX_CONCURRENT_STREAMS:
+      max_concurrent_streams_ = std::min(static_cast<size_t>(value),
+                                         max_concurrent_stream_limit_);
+      ProcessPendingCreateStreams();
+      break;
+    case spdy::SETTINGS_INITIAL_WINDOW_SIZE:
+      // INITIAL_WINDOW_SIZE updates initial_send_window_size_ only.
+      // TODO(rtenneti): discuss with the server team about
+      // initial_recv_window_size_.
+      int32 prev_initial_send_window_size = initial_send_window_size_;
+      initial_send_window_size_ = value;
+      int32 delta_window_size =
+          initial_send_window_size_ - prev_initial_send_window_size;
+      UpdateStreamsSendWindowSize(delta_window_size);
+      break;
   }
 }
 
 void SpdySession::UpdateStreamsSendWindowSize(int32 delta_window_size) {
   ActiveStreamMap::iterator it;
   for (it = active_streams_.begin(); it != active_streams_.end(); ++it) {
     const scoped_refptr<SpdyStream>& stream = it->second;
     DCHECK(stream);
     stream->AdjustSendWindowSize(delta_window_size);
   }
@@ skipping 32 matching lines @@
 
 void SpdySession::SendTrailingPing() {
   DCHECK(trailing_ping_pending_);
   trailing_ping_pending_ = false;
   WritePingFrame(next_ping_id_);
 }
 
 void SpdySession::WritePingFrame(uint32 unique_id) {
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<spdy::SpdyPingControlFrame> ping_frame(
-      spdy::SpdyFramer::CreatePingFrame(next_ping_id_));
-  QueueFrame(ping_frame.get(), SPDY_PRIORITY_HIGHEST, NULL);
+      buffered_spdy_framer_->CreatePingFrame(next_ping_id_));
+  QueueFrame(
+      ping_frame.get(), buffered_spdy_framer_->GetHighestPriority(), NULL);
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_PING,
         make_scoped_refptr(new NetLogSpdyPingParameter(next_ping_id_, "sent")));
   }
   if (unique_id % 2 != 0) {
     next_ping_id_ += 2;
     ++pings_in_flight_;
     need_to_send_ping_ = false;
@@ skipping 140 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