base::Bind: Convert most of net/http.

net/spdy/spdy_session_unittest.cc

 // Copyright (c) 2011 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/ip_endpoint.h"
 #include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
@@ skipping 11 matching lines @@
   }
  protected:
   virtual void TearDown() {
     // Wanted to be 100% sure PING is disabled.
     SpdySession::set_enable_ping_based_connection_checking(false);
   }
 };
 
 class TestSpdyStreamDelegate : public net::SpdyStream::Delegate {
  public:
-  explicit TestSpdyStreamDelegate(OldCompletionCallback* callback)
+  explicit TestSpdyStreamDelegate(const CompletionCallback& callback)
       : callback_(callback) {}
   virtual ~TestSpdyStreamDelegate() {}
 
   virtual bool OnSendHeadersComplete(int status) { return true; }
 
   virtual int OnSendBody() {
     return ERR_UNEXPECTED;
   }
 
   virtual int OnSendBodyComplete(int /*status*/, bool* /*eof*/) {
     return ERR_UNEXPECTED;
   }
 
   virtual int OnResponseReceived(const spdy::SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) {
     return status;
   }
 
   virtual void OnDataReceived(const char* buffer, int bytes) {
   }
 
   virtual void OnDataSent(int length) {
   }
 
   virtual void OnClose(int status) {
-    OldCompletionCallback* callback = callback_;
-    callback_ = NULL;
-    callback->Run(OK);
+    CompletionCallback callback = callback_;
+    callback_.Reset();
+    callback.Run(OK);
   }
 
   virtual void set_chunk_callback(net::ChunkCallback *) {}
 
  private:
-  OldCompletionCallback* callback_;
+  CompletionCallback callback_;
 };
 
-
 // Test the SpdyIOBuffer class.
 TEST_F(SpdySessionTest, SpdyIOBuffer) {
   std::priority_queue<SpdyIOBuffer> queue_;
   const size_t kQueueSize = 100;
 
   // Insert 100 items; pri 100 to 1.
   for (size_t index = 0; index < kQueueSize; ++index) {
     SpdyIOBuffer buffer(new IOBuffer(), 0, kQueueSize - index, NULL);
     queue_.push(buffer);
   }
@@ skipping 131 matching lines @@
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
                                  transport_params, MEDIUM, CompletionCallback(),
                                  http_session->GetTransportSocketPool(),
                                  BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   scoped_refptr<SpdyStream> spdy_stream1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(OK, session->CreateStream(url,
                                       MEDIUM,
                                       &spdy_stream1,
                                       BoundNetLog(),
-                                      &callback1));
+                                      callback1.callback()));
   scoped_ptr<TestSpdyStreamDelegate> delegate(
-      new TestSpdyStreamDelegate(&callback1));
+      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);
   SpdySession::set_connection_at_risk_of_loss_seconds(0);
   SpdySession::set_trailing_ping_delay_time_ms(0);
   SpdySession::set_hung_interval_ms(50);
 
@@ skipping 60 matching lines @@
                                 false,
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
                                  transport_params, MEDIUM, CompletionCallback(),
                                  http_session->GetTransportSocketPool(),
                                  BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   scoped_refptr<SpdyStream> spdy_stream1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   EXPECT_EQ(OK, session->CreateStream(url,
                                       MEDIUM,
                                       &spdy_stream1,
                                       BoundNetLog(),
-                                      &callback1));
+                                      callback1.callback()));
   scoped_ptr<TestSpdyStreamDelegate> delegate(
-      new TestSpdyStreamDelegate(&callback1));
+      new TestSpdyStreamDelegate(callback1.callback()));
   spdy_stream1->SetDelegate(delegate.get());
 
   // Enable sending of PING.
   SpdySession::set_enable_ping_based_connection_checking(true);
   SpdySession::set_connection_at_risk_of_loss_seconds(0);
   SpdySession::set_trailing_ping_delay_time_ms(0);
   SpdySession::set_hung_interval_ms(0);
 
   // Send a PING frame.
   session->WritePingFrame(1);
@@ skipping 14 matching lines @@
 
   EXPECT_TRUE(session->IsClosed());
   EXPECT_EQ(0u, session->num_active_streams());
   EXPECT_EQ(0u, session->num_unclaimed_pushed_streams());
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 
   // Delete the first session.
   session = NULL;
 }
 
-class StreamReleaserCallback : public CallbackRunner<Tuple1<int> > {
+class StreamReleaserCallback : public TestCompletionCallbackBase {
  public:
   StreamReleaserCallback(SpdySession* session,
                          SpdyStream* first_stream)
-      : session_(session), first_stream_(first_stream) {}
-  ~StreamReleaserCallback() {}
+      : session_(session),
+        first_stream_(first_stream),
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&StreamReleaserCallback::OnComplete,
+                       base::Unretained(this)))) {
+  }
 
-  int WaitForResult() { return callback_.WaitForResult(); }
+  virtual ~StreamReleaserCallback() {}
 
-  virtual void RunWithParams(const Tuple1<int>& params) {
+  scoped_refptr<SpdyStream>* stream() { return &stream_; }
+
+  const CompletionCallback& callback() const { return callback_; }
+
+ private:
+  void OnComplete(int result) {
     session_->CloseSessionOnError(ERR_FAILED, false);
     session_ = NULL;
     first_stream_->Cancel();
     first_stream_ = NULL;
     stream_->Cancel();
     stream_ = NULL;
-    callback_.RunWithParams(params);
+    SetResult(result);
   }
 
-  scoped_refptr<SpdyStream>* stream() { return &stream_; }
-
- private:
   scoped_refptr<SpdySession> session_;
   scoped_refptr<SpdyStream> first_stream_;
   scoped_refptr<SpdyStream> stream_;
-  TestOldCompletionCallback callback_;
+  CompletionCallback callback_;
 };
 
 // TODO(kristianm): Could also test with more sessions where some are idle,
 // and more than one session to a HostPortPair.
 TEST_F(SpdySessionTest, CloseIdleSessions) {
   SpdySessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> http_session(
   SpdySessionDependencies::SpdyCreateSession(&session_deps));
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
 
   // Set up session 1
   const std::string kTestHost1("http://www.a.com");
   HostPortPair test_host_port_pair1(kTestHost1, 80);
   HostPortProxyPair pair1(test_host_port_pair1, ProxyServer::Direct());
   scoped_refptr<SpdySession> session1 =
       spdy_session_pool->Get(pair1, BoundNetLog());
   scoped_refptr<SpdyStream> spdy_stream1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   GURL url1(kTestHost1);
   EXPECT_EQ(OK, session1->CreateStream(url1,
                                       MEDIUM, /* priority, not important */
                                       &spdy_stream1,
                                       BoundNetLog(),
-                                      &callback1));
+                                      callback1.callback()));
 
   // Set up session 2
   const std::string kTestHost2("http://www.b.com");
   HostPortPair test_host_port_pair2(kTestHost2, 80);
   HostPortProxyPair pair2(test_host_port_pair2, ProxyServer::Direct());
   scoped_refptr<SpdySession> session2 =
       spdy_session_pool->Get(pair2, BoundNetLog());
   scoped_refptr<SpdyStream> spdy_stream2;
-  TestOldCompletionCallback callback2;
+  TestCompletionCallback callback2;
   GURL url2(kTestHost2);
-  EXPECT_EQ(OK, session2->CreateStream(url2,
-                                      MEDIUM, /* priority, not important */
-                                      &spdy_stream2,
-                                      BoundNetLog(),
-                                      &callback2));
+  EXPECT_EQ(OK, session2->CreateStream(
+      url2, MEDIUM, /* priority, not important */
+      &spdy_stream2, BoundNetLog(), callback2.callback()));
 
   // Set up session 3
   const std::string kTestHost3("http://www.c.com");
   HostPortPair test_host_port_pair3(kTestHost3, 80);
   HostPortProxyPair pair3(test_host_port_pair3, ProxyServer::Direct());
   scoped_refptr<SpdySession> session3 =
       spdy_session_pool->Get(pair3, BoundNetLog());
   scoped_refptr<SpdyStream> spdy_stream3;
-  TestOldCompletionCallback callback3;
+  TestCompletionCallback callback3;
   GURL url3(kTestHost3);
-  EXPECT_EQ(OK, session3->CreateStream(url3,
-                                      MEDIUM, /* priority, not important */
-                                      &spdy_stream3,
-                                      BoundNetLog(),
-                                      &callback3));
+  EXPECT_EQ(OK, session3->CreateStream(
+      url3, MEDIUM, /* priority, not important */
+      &spdy_stream3, BoundNetLog(), callback3.callback()));
 
   // All sessions are active and not closed
   EXPECT_TRUE(session1->is_active());
   EXPECT_FALSE(session1->IsClosed());
   EXPECT_TRUE(session2->is_active());
   EXPECT_FALSE(session2->IsClosed());
   EXPECT_TRUE(session3->is_active());
   EXPECT_FALSE(session3->IsClosed());
 
   // Should not do anything, all are active
@@ skipping 102 matching lines @@
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
                                  transport_params, MEDIUM, CompletionCallback(),
                                  http_session->GetTransportSocketPool(),
                                  BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   scoped_refptr<SpdyStream> spdy_stream1;
-  TestOldCompletionCallback callback1;
+  TestCompletionCallback callback1;
   GURL url("http://www.google.com");
   EXPECT_EQ(OK,
             session->CreateStream(url,
                                   MEDIUM, /* priority, not important */
                                   &spdy_stream1,
                                   BoundNetLog(),
-                                  &callback1));
+                                  callback1.callback()));
 
   StreamReleaserCallback stream_releaser(session, spdy_stream1);
 
   ASSERT_EQ(ERR_IO_PENDING,
             session->CreateStream(url,
                                   MEDIUM, /* priority, not important */
                                   stream_releaser.stream(),
                                   BoundNetLog(),
-                                  &stream_releaser));
+                                  stream_releaser.callback()));
 
   // Make sure |stream_releaser| holds the last refs.
   session = NULL;
   spdy_stream1 = NULL;
 
   EXPECT_EQ(OK, stream_releaser.WaitForResult());
 }
 
 // Start with max concurrent streams set to 1.  Request two streams.  When the
 // first completes, have the callback close itself, which should trigger the
@@ skipping 47 matching lines @@
                                 false));
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   EXPECT_EQ(OK, connection->Init(test_host_port_pair.ToString(),
                                  transport_params, MEDIUM, CompletionCallback(),
                                  http_session->GetTransportSocketPool(),
                                  BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   // Use scoped_ptr to let us invalidate the memory when we want to, to trigger
   // a valgrind error if the callback is invoked when it's not supposed to be.
-  scoped_ptr<TestOldCompletionCallback> callback(new TestOldCompletionCallback);
+  scoped_ptr<TestCompletionCallback> callback(new TestCompletionCallback);
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   scoped_refptr<SpdyStream> spdy_stream1;
   GURL url("http://www.google.com");
   ASSERT_EQ(OK,
             session->CreateStream(url,
                                   MEDIUM, /* priority, not important */
                                   &spdy_stream1,
                                   BoundNetLog(),
-                                  callback.get()));
+                                  callback->callback()));
 
   scoped_refptr<SpdyStream> spdy_stream2;
   ASSERT_EQ(ERR_IO_PENDING,
             session->CreateStream(url,
                                   MEDIUM, /* priority, not important */
                                   &spdy_stream2,
                                   BoundNetLog(),
-                                  callback.get()));
+                                  callback->callback()));
 
   // Release the first one, this will allow the second to be created.
   spdy_stream1->Cancel();
   spdy_stream1 = NULL;
 
   session->CancelPendingCreateStreams(&spdy_stream2);
   callback.reset();
 
   // Should not crash when running the pending callback.
   MessageLoop::current()->RunAllPending();
@@ skipping 233 matching lines @@
   test_http_server_properties->SetSpdySettings(test_host_port_pair,
                                                test_settings);
   EXPECT_NE(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
   spdy_session_pool->OnIPAddressChanged();
   EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
 }
 
 }  // namespace net