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

net/spdy/spdy_session_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_session.h"
 
 #include "net/base/host_cache.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log_unittest.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_spdy2.h"
 #include "testing/platform_test.h"
 
 using namespace net::test_spdy2;
 
 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 15 matching lines @@
   virtual void OnDataSent(int length) OVERRIDE {}
   virtual void OnClose(int status) OVERRIDE {
     stream_->Close();
   }
  private:
   SpdyStream* stream_;
 };
 
 } // namespace
 
-// TODO(cbentzel): Expose compression setter/getter in public SpdySession
-//                 interface rather than going through all these contortions.
 class SpdySessionSpdy2Test : public PlatformTest {
  protected:
-  virtual void SetUp() {
-    SpdySession::set_default_protocol(kProtoSPDY2);
+  void SetUp() {
+    g_delta_seconds = 0;
   }
-
- private:
-  SpdyTestStateHelper spdy_state_;
 };
 
 class TestSpdyStreamDelegate : public net::SpdyStream::Delegate {
  public:
   explicit TestSpdyStreamDelegate(const CompletionCallback& callback)
       : callback_(callback) {}
   virtual ~TestSpdyStreamDelegate() {}
 
   virtual bool OnSendHeadersComplete(int status) OVERRIDE { return true; }
 
@@ skipping 184 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(SpdySessionSpdy2Test, 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 SPDY2 framer.
-  session->buffered_spdy_framer_.reset(new BufferedSpdyFramer(2));
+  session->buffered_spdy_framer_.reset(new BufferedSpdyFramer(2, 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)["url"] = "/";
 
   scoped_refptr<SpdyStream> stream(
       new SpdyStream(session, false, session->net_log_));
   stream->set_spdy_headers(request_headers.Pass());
   session->ActivateStream(stream);
 
   SpdyHeaderBlock headers;
   headers["url"] = "http://www.google.com/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["url"] = "http://www.google.com/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);
 
   // Delete the session.
@@ skipping 57 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 1083 matching lines @@
   session->CloseSessionOnError(ERR_ABORTED, true, "");
 
   EXPECT_TRUE(spdy_stream1->closed());
   EXPECT_TRUE(spdy_stream2->closed());
 
   spdy_stream1 = NULL;
   spdy_stream2 = NULL;
 }
 
 }  // namespace net