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

net/spdy/spdy_session.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 #pragma once
 
 #include <deque>
 #include <list>
@@ skipping 67 matching lines @@
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
   // Create a new stream for a given |url|.  Writes it out to |spdy_stream|.
   // Returns a net error code, possibly ERR_IO_PENDING.
   int CreateStream(
       const GURL& url,
       RequestPriority priority,
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log,
-      OldCompletionCallback* callback);
+      const CompletionCallback& callback);
 
   // Remove PendingCreateStream objects on transaction deletion
   void CancelPendingCreateStreams(const scoped_refptr<SpdyStream>* spdy_stream);
 
   // Used by SpdySessionPool to initialize with a pre-existing SSL socket. For
   // testing, setting is_secure to false allows initialization with a
   // pre-existing TCP socket.
   // Returns OK on success, or an error on failure.
   net::Error InitializeWithSocket(ClientSocketHandle* connection,
                                   bool is_secure,
@@ skipping 128 matching lines @@
   // Returns true if flow control is enabled for the session.
   bool is_flow_control_enabled() const {
     return flow_control_;
   }
 
   const BoundNetLog& net_log() const { return net_log_; }
 
   int GetPeerAddress(AddressList* address) const;
   int GetLocalAddress(IPEndPoint* address) const;
 
-  // LayeredPool methods:
+  // LayeredPool implementation.
   virtual bool CloseOneIdleConnection() OVERRIDE;
 
  private:
   friend class base::RefCounted<SpdySession>;
+
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, Ping);
   FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, FailedPing);
   FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, GetActivePushStream);
 
   struct PendingCreateStream {
     PendingCreateStream(const GURL& url, RequestPriority priority,
                         scoped_refptr<SpdyStream>* spdy_stream,
                         const BoundNetLog& stream_net_log,
-                        OldCompletionCallback* callback)
-        : url(&url), priority(priority), spdy_stream(spdy_stream),
-          stream_net_log(&stream_net_log), callback(callback) { }
+                        const CompletionCallback& callback)
+        : url(&url),
+          priority(priority),
+          spdy_stream(spdy_stream),
+          stream_net_log(&stream_net_log),
+          callback(callback) {}
+    ~PendingCreateStream();
 
     const GURL* url;
     RequestPriority priority;
     scoped_refptr<SpdyStream>* spdy_stream;
     const BoundNetLog* stream_net_log;
-    OldCompletionCallback* callback;
+    CompletionCallback callback;
   };
   typedef std::queue<PendingCreateStream, std::list< PendingCreateStream> >
       PendingCreateStreamQueue;
   typedef std::map<int, scoped_refptr<SpdyStream> > ActiveStreamMap;
   // Only HTTP push a stream.
   typedef std::map<std::string, scoped_refptr<SpdyStream> > PushedStreamMap;
   typedef std::priority_queue<SpdyIOBuffer> OutputQueue;
 
   struct CallbackResultPair {
     CallbackResultPair() : result(OK) {}
-    CallbackResultPair(OldCompletionCallback* callback_in, int result_in)
+    CallbackResultPair(const CompletionCallback& callback_in, int result_in)
         : callback(callback_in), result(result_in) {}
+    ~CallbackResultPair();
 
-    OldCompletionCallback* callback;
+    CompletionCallback callback;
     int result;
   };
 
   typedef std::map<const scoped_refptr<SpdyStream>*, CallbackResultPair>
       PendingCallbackMap;
 
   enum State {
     IDLE,
     CONNECTING,
     CONNECTED,
@@ skipping 336 matching lines @@
   const spdy::SpdyControlFlags flags_;
   const spdy::SpdyStreamId id_;
   const spdy::SpdyStreamId associated_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySynParameter);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_