SPDY - replaced SpdySettings (list) with SettingsMap

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"
@@ skipping 15 matching lines @@
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/server_bound_cert_service.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.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(
     const linked_ptr<SpdyHeaderBlock>& headers,
     SpdyControlFlags flags,
     SpdyStreamId id,
     SpdyStreamId associated_stream)
     : headers_(headers),
@@ skipping 98 matching lines @@
   ~NetLogSpdySettingParameter() {}
   const SpdySettingsIds id_;
   const SpdySettingsFlags flags_;
   const uint32 value_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySettingParameter);
 };
 
 class NetLogSpdySettingsParameter : public NetLog::EventParameters {
  public:
-  explicit NetLogSpdySettingsParameter(const SpdySettings& settings)
+  explicit NetLogSpdySettingsParameter(const SettingsMap& settings)
       : settings_(settings) {}
 
   virtual Value* ToValue() const {
     DictionaryValue* dict = new DictionaryValue();
     ListValue* settings = new ListValue();
-    for (SpdySettings::const_iterator it = settings_.begin();
+    for (SettingsMap::const_iterator it = settings_.begin();
          it != settings_.end(); ++it) {
+      const SpdySettingsIds id = it->first;
+      const SpdySettingsFlags flags = it->second.first;
+      const uint32 value = it->second.second;
       settings->Append(new StringValue(
-          base::StringPrintf("[%u:%u]", it->first.id(), it->second)));
+          base::StringPrintf("[id:%u flags:%u value:%u]", id, flags, value)));
     }
     dict->Set("settings", settings);
     return dict;
   }
 
  private:
   ~NetLogSpdySettingsParameter() {}
-  const SpdySettings settings_;
+  const SettingsMap settings_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySettingsParameter);
 };
 
 class NetLogSpdyWindowUpdateParameter : public NetLog::EventParameters {
  public:
   NetLogSpdyWindowUpdateParameter(SpdyStreamId stream_id, int32 delta)
       : stream_id_(stream_id), delta_(delta) {}
 
   virtual Value* ToValue() const {
@@ skipping 1531 matching lines @@
     value = it->second.second;
   uint32 cwnd = ApplyCwndFieldTrialPolicy(value);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsCwndSent", cwnd, 1, 200, 100);
   if (cwnd != value) {
     http_server_properties_->SetSpdySetting(
         host_port_pair(), id, SETTINGS_FLAG_PLEASE_PERSIST, cwnd);
   }
 
   const SettingsMap& settings_map_new =
       http_server_properties_->GetSpdySettings(host_port_pair());
-
-  SpdySettings settings;
   for (SettingsMap::const_iterator i = settings_map_new.begin(),
            end = settings_map_new.end(); i != end; ++i) {
     const SpdySettingsIds new_id = i->first;
-    const SpdySettingsFlags new_flags = i->second.first;
     const uint32 new_val = i->second.second;
     HandleSetting(new_id, new_val);
-    SettingsFlagsAndId flags_and_id(new_flags, new_id);
-    settings.push_back(SpdySetting(flags_and_id, new_val));
   }
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_SEND_SETTINGS,
-      make_scoped_refptr(new NetLogSpdySettingsParameter(settings)));
+      make_scoped_refptr(new NetLogSpdySettingsParameter(settings_map_new)));
 
   // Create the SETTINGS frame and send it.
   DCHECK(buffered_spdy_framer_.get());
   scoped_ptr<SpdySettingsControlFrame> settings_frame(
-      buffered_spdy_framer_->CreateSettings(settings));
+      buffered_spdy_framer_->CreateSettings(settings_map_new));
   sent_settings_ = true;
   QueueFrame(settings_frame.get(), 0, NULL);
 }
 
 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);
       ProcessPendingCreateStreams();
@@ skipping 213 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