Move a number of static variables SPDY to HttpNetworkSession::Params.

net/spdy/spdy_session_spdy3_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_session.h"
 
 #include "net/base/cert_test_util.h"
 #include "net/base/host_cache.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/test_data_directory.h"
 #include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
 #include "net/spdy/spdy_test_util_spdy3.h"
 #include "testing/platform_test.h"
 
 using namespace net::test_spdy3;
 
 namespace net {
 
 namespace {
 
-base::TimeTicks the_near_future() {
-  return base::TimeTicks::Now() +
-      base::TimeDelta::FromSeconds(301);
+static int g_delta_seconds = 0;
+base::TimeTicks TheNearFuture() {
+  return base::TimeTicks::Now() + base::TimeDelta::FromSeconds(g_delta_seconds);
 }
 
 class ClosingDelegate : public SpdyStream::Delegate {
  public:
   ClosingDelegate(SpdyStream* stream) : stream_(stream) {}
 
   // SpdyStream::Delegate implementation:
   virtual bool OnSendHeadersComplete(int status) OVERRIDE {
     return true;
   }
@@ skipping 55 matching lines @@
     callback_.Reset();
     callback.Run(OK);
   }
 
  private:
   CompletionCallback callback_;
 };
 
 } // namespace
 
-// TODO(cbentzel): Expose compression setter/getter in public SpdySession
-//                 interface rather than going through all these contortions.
 class SpdySessionSpdy3Test : public PlatformTest {
  protected:
-  virtual void SetUp() {
-    SpdySession::set_default_protocol(kProtoSPDY3);
+  void SetUp() {
+    g_delta_seconds = 0;
   }
+};
 
- private:
-  SpdyTestStateHelper spdy_state_;
-};
 // Test the SpdyIOBuffer class.
 TEST_F(SpdySessionSpdy3Test, SpdyIOBuffer) {
   std::priority_queue<SpdyIOBuffer> queue_;
   const size_t kQueueSize = 100;
 
   // Insert items with random priority and increasing buffer size
   for (size_t index = 0; index < kQueueSize; ++index) {
     queue_.push(SpdyIOBuffer(
         new IOBufferWithSize(index + 1),
         index + 1,
@@ skipping 78 matching lines @@
   // Delete the first session.
   session = NULL;
 
   // Delete the second session.
   spdy_session_pool->Remove(session2);
   session2 = NULL;
 }
 
 TEST_F(SpdySessionSpdy3Test, ClientPing) {
   SpdySessionDependencies session_deps;
+  session_deps.enable_ping = true;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> read_ping(ConstructSpdyPing(1));
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<SpdyFrame> write_ping(ConstructSpdyPing(1));
   MockWrite writes[] = {
@@ skipping 44 matching lines @@
                                       MEDIUM,
                                       &spdy_stream1,
                                       BoundNetLog(),
                                       callback1.callback()));
   scoped_ptr<TestSpdyStreamDelegate> delegate(
       new TestSpdyStreamDelegate(callback1.callback()));
   spdy_stream1->SetDelegate(delegate.get());
 
   base::TimeTicks before_ping_time = base::TimeTicks::Now();
 
-  // Enable sending of PING.
-  SpdySession::set_enable_ping_based_connection_checking(true);
   session->set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(0));
   session->set_hung_interval(base::TimeDelta::FromMilliseconds(50));
 
   session->SendPrefacePingIfNoneInFlight();
 
   EXPECT_EQ(OK, callback1.WaitForResult());
 
   session->CheckPingStatus(before_ping_time);
 
   EXPECT_EQ(0, session->pings_in_flight());
@@ skipping 79 matching lines @@
   // Delete the session.
   session = NULL;
 }
 
 TEST_F(SpdySessionSpdy3Test, DeleteExpiredPushStreams) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
+  session_deps.time_func = TheNearFuture;
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.google.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(pair, BoundNetLog());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
   // Give the session a SPDY3 framer.
-  session->buffered_spdy_framer_.reset(new BufferedSpdyFramer(3));
+  session->buffered_spdy_framer_.reset(new BufferedSpdyFramer(3, false));
 
   // Create the associated stream and add to active streams.
   scoped_ptr<SpdyHeaderBlock> request_headers(new SpdyHeaderBlock);
   (*request_headers)[":scheme"] = "http";
   (*request_headers)[":host"] = "www.google.com";
   (*request_headers)[":path"] = "/";
 
   scoped_refptr<SpdyStream> stream(
       new SpdyStream(session, false, session->net_log_));
   stream->set_spdy_headers(request_headers.Pass());
   session->ActivateStream(stream);
 
   SpdyHeaderBlock headers;
   headers[":scheme"] = "http";
   headers[":host"] = "www.google.com";
   headers[":path"] = "/a.dat";
   session->OnSynStream(2, 1, 0, 0, true, false, headers);
 
   // Verify that there is one unclaimed push stream.
   EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
   SpdySession::PushedStreamMap::iterator  iter  =
       session->unclaimed_pushed_streams_.find("http://www.google.com/a.dat");
   EXPECT_TRUE(session->unclaimed_pushed_streams_.end() != iter);
 
   // Shift time.
-  SpdySession::set_time_func(the_near_future);
+  g_delta_seconds = 301;
 
   headers[":scheme"] = "http";
   headers[":host"] = "www.google.com";
   headers[":path"] = "/b.dat";
   session->OnSynStream(4, 1, 0, 0, true, false, headers);
 
   // Verify that the second pushed stream evicted the first pushed stream.
   EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
   iter = session->unclaimed_pushed_streams_.find("http://www.google.com/b.dat");
   EXPECT_TRUE(session->unclaimed_pushed_streams_.end() != iter);
@@ skipping 59 matching lines @@
   TestCompletionCallback callback1;
   EXPECT_EQ(OK, session->CreateStream(url,
                                       MEDIUM,
                                       &spdy_stream1,
                                       BoundNetLog(),
                                       callback1.callback()));
   scoped_ptr<TestSpdyStreamDelegate> delegate(
       new TestSpdyStreamDelegate(callback1.callback()));
   spdy_stream1->SetDelegate(delegate.get());
 
-  // Enable sending of PING.
-  SpdySession::set_enable_ping_based_connection_checking(true);
   session->set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(0));
   session->set_hung_interval(base::TimeDelta::FromSeconds(0));
 
   // Send a PING frame.
   session->WritePingFrame(1);
   EXPECT_LT(0, session->pings_in_flight());
   EXPECT_GE(session->next_ping_id(), static_cast<uint32>(1));
   EXPECT_TRUE(session->check_ping_status_pending());
 
   // Assert session is not closed.
@@ skipping 350 matching lines @@
   const uint32 kInitialRecvWindowSize = 10 * 1024 * 1024;
   settings[kSpdySettingsIds1] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
   settings[kSpdySettingsIds2] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kInitialRecvWindowSize);
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(settings));
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
   };
-  SpdySession::set_default_initial_recv_window_size(kInitialRecvWindowSize);
+  session_deps.initial_recv_window_size = kInitialRecvWindowSize;
 
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
@@ skipping 1039 matching lines @@
                                  BoundNetLog()));
 
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
   EXPECT_TRUE(session->VerifyDomainAuthentication("www.example.org"));
   EXPECT_TRUE(session->VerifyDomainAuthentication("mail.example.org"));
   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.example.com"));
   EXPECT_FALSE(session->VerifyDomainAuthentication("mail.google.com"));
 }
 
 }  // namespace net