SPDY - replaced SpdySettings (list) with SettingsMap

net/spdy/spdy_framer.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_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 53 matching lines @@
   uint32 id() const { return id_; }
   uint8 flags() const { return flags_; }
 
  private:
   static void ConvertFlagsAndIdForSpdy2(uint32* val);
 
   uint8 flags_;
   uint32 id_;
 };
 
-// A datastructure for holding a set of ID/value pairs for a SETTINGS frame.
-typedef std::pair<SettingsFlagsAndId, uint32> SpdySetting;
-typedef std::list<SpdySetting> SpdySettings;
-// SpdySettingsMap has unique (flags, value) pair for give SpdySetting ID.
+// SpdySettingsMap has unique (flags, value) pair for given SpdySettingsIds ID.
 typedef std::pair<SpdySettingsFlags, uint32> SettingsFlagsAndValue;
 typedef std::map<SpdySettingsIds, SettingsFlagsAndValue> SettingsMap;
 
 // A datastrcture for holding the contents of a CREDENTIAL frame.
 struct NET_EXPORT_PRIVATE SpdyCredential {
   SpdyCredential();
   ~SpdyCredential();
 
   uint16 slot;
   std::vector<std::string> certs;
@@ skipping 208 matching lines @@
   SpdySynReplyControlFrame* CreateSynReply(SpdyStreamId stream_id,
                                            SpdyControlFlags flags,
                                            bool compressed,
                                            const SpdyHeaderBlock* headers);
 
   SpdyRstStreamControlFrame* CreateRstStream(SpdyStreamId stream_id,
                                              SpdyStatusCodes status) const;
 
   // Creates an instance of SpdySettingsControlFrame. The SETTINGS frame is
   // used to communicate name/value pairs relevant to the communication channel.
-  SpdySettingsControlFrame* CreateSettings(const SpdySettings& values) const;
+  SpdySettingsControlFrame* CreateSettings(const SettingsMap& values) const;
 
   // Creates an instance of SpdyPingControlFrame. The unique_id is used to
   // identify the ping request/response.
   SpdyPingControlFrame* CreatePingFrame(uint32 unique_id) const;
 
   // Creates an instance of SpdyGoAwayControlFrame. The GOAWAY frame is used
   // prior to the shutting down of the TCP connection, and includes the
   // stream_id of the last stream the sender of the frame is willing to process
   // to completion.
   SpdyGoAwayControlFrame* CreateGoAway(SpdyStreamId last_accepted_stream_id,
@@ skipping 15 matching lines @@
 
   // Creates an instance of SpdyCredentialControlFrame.  The CREDENTIAL
   // frame is used to send a client certificate to the server when
   // request more than one origin are sent over the same SPDY session.
   SpdyCredentialControlFrame* CreateCredentialFrame(
       const SpdyCredential& credential) const;
 
   // Given a SpdySettingsControlFrame, extract the settings.
   // Returns true on successful parse, false otherwise.
   static bool ParseSettings(const SpdySettingsControlFrame* frame,
-                            SpdySettings* settings);
+                            SettingsMap* settings);
 
   // Given a SpdyCredentialControlFrame's payload, extract the credential.
   // Returns true on successful parse, false otherwise.
   // TODO(hkhalil): Implement CREDENTIAL frame parsing in SpdyFramer
   // and eliminate this method.
   static bool ParseCredentialData(const char* data, size_t len,
                                   SpdyCredential* credential);
 
   // Create a data frame.
   // |stream_id| is the stream  for this frame
@@ skipping 238 matching lines @@
   // starts with HTTP.  If it does, we likely have an HTTP response.   This
   // isn't guaranteed though: we could have gotten a settings frame and then
   // corrupt data that just looks like HTTP, but deterministic checking requires
   // a lot more state.
   bool probable_http_response_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_