SPDY - persist SPDY settings.

net/spdy/spdy_websocket_stream_spdy2_unittest.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_websocket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 174 matching lines @@
   virtual ~SpdyWebSocketStreamSpdy2Test() {}
 
   virtual void SetUp() {
     SpdySession::set_default_protocol(SSLClientSocket::kProtoSPDY2);
 
     host_port_pair_.set_host("example.com");
     host_port_pair_.set_port(80);
     host_port_proxy_pair_.first = host_port_pair_;
     host_port_proxy_pair_.second = ProxyServer::Direct();
 
-    const size_t max_concurrent_streams = 1;
-    SettingsFlagsAndId id(SETTINGS_FLAG_PLEASE_PERSIST,
-                                SETTINGS_MAX_CONCURRENT_STREAMS);
-    spdy_settings_to_set_.push_back(
-        SpdySetting(id, max_concurrent_streams));
+    spdy_settings_id_to_set_ = SETTINGS_MAX_CONCURRENT_STREAMS;
+    spdy_settings_flags_to_set_ = SETTINGS_FLAG_PLEASE_PERSIST;
+    spdy_settings_value_to_set_ = 1;
 
-    SettingsFlagsAndId id1(SETTINGS_FLAG_PERSISTED,
-                                 SETTINGS_MAX_CONCURRENT_STREAMS);
+    SettingsFlagsAndId id1(SETTINGS_FLAG_PERSISTED, spdy_settings_id_to_set_);
     spdy_settings_to_send_.push_back(
-        SpdySetting(id1, max_concurrent_streams));
+        SpdySetting(id1, spdy_settings_value_to_set_));
   }
 
   virtual void TearDown() {
     MessageLoop::current()->RunAllPending();
   }
 
   void Prepare(SpdyStreamId stream_id) {
     stream_id_ = stream_id;
 
     const char* const request_headers[] = {
@@ skipping 37 matching lines @@
                   MockWrite* writes, size_t writes_count,
                   bool throttling) {
     data_.reset(new OrderedSocketData(reads, reads_count,
                                       writes, writes_count));
     session_deps_.socket_factory->AddSocketDataProvider(data_.get());
     http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
     SpdySessionPool* spdy_session_pool(http_session_->spdy_session_pool());
 
     if (throttling) {
       // Set max concurrent streams to 1.
-      spdy_session_pool->http_server_properties()->SetSpdySettings(
-          host_port_pair_, spdy_settings_to_set_);
+      spdy_session_pool->http_server_properties()->SetSpdySetting(
+          host_port_pair_,
+          spdy_settings_id_to_set_,
+          spdy_settings_flags_to_set_,
+          spdy_settings_value_to_set_);
     }
 
     EXPECT_FALSE(spdy_session_pool->HasSession(host_port_proxy_pair_));
     session_ = spdy_session_pool->Get(host_port_proxy_pair_, BoundNetLog());
     EXPECT_TRUE(spdy_session_pool->HasSession(host_port_proxy_pair_));
     transport_params_ = new TransportSocketParams(host_port_pair_, MEDIUM,
                                                   false, false);
     TestCompletionCallback callback;
     scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
     EXPECT_EQ(ERR_IO_PENDING,
               connection->Init(host_port_pair_.ToString(), transport_params_,
                                MEDIUM, callback.callback(),
                                http_session_->GetTransportSocketPool(
                                    HttpNetworkSession::NORMAL_SOCKET_POOL),
                                BoundNetLog()));
     EXPECT_EQ(OK, callback.WaitForResult());
     return session_->InitializeWithSocket(connection.release(), false, OK);
   }
   void SendRequest() {
     linked_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
     (*headers)["url"] = "ws://example.com/echo";
     (*headers)["origin"] = "http://example.com/wsdemo";
 
     websocket_stream_->SendRequest(headers);
   }
 
-  SpdySettings spdy_settings_to_set_;
+  SpdySettingsIds spdy_settings_id_to_set_;
+  SpdySettingsFlags spdy_settings_flags_to_set_;
+  uint32 spdy_settings_value_to_set_;
   SpdySettings spdy_settings_to_send_;
   SpdySessionDependencies session_deps_;
   scoped_ptr<OrderedSocketData> data_;
   scoped_refptr<HttpNetworkSession> http_session_;
   scoped_refptr<SpdySession> session_;
   scoped_refptr<TransportSocketParams> transport_params_;
   scoped_ptr<SpdyWebSocketStream> websocket_stream_;
   SpdyStreamId stream_id_;
   scoped_ptr<SpdyFrame> request_frame_;
   scoped_ptr<SpdyFrame> response_frame_;
@@ skipping 315 matching lines @@
   EXPECT_EQ(OK, events[7].result);
 
   // EOF close SPDY session.
   EXPECT_TRUE(!http_session_->spdy_session_pool()->HasSession(
       host_port_proxy_pair_));
   EXPECT_TRUE(data()->at_read_eof());
   EXPECT_TRUE(data()->at_write_eof());
 }
 
 }  // namespace net