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

net/http/http_pipelined_connection_impl.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_HTTP_HTTP_PIPELINED_CONNECTION_IMPL_H_
 #define NET_HTTP_HTTP_PIPELINED_CONNECTION_IMPL_H_
 #pragma once
 
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "base/memory/linked_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/task.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_pipelined_connection.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_parser.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 53 matching lines @@
   // pass-through methods in HttpPipelinedStream.
   void InitializeParser(int pipeline_id,
                         const HttpRequestInfo* request,
                         const BoundNetLog& net_log);
 
   int SendRequest(int pipeline_id,
                   const std::string& request_line,
                   const HttpRequestHeaders& headers,
                   UploadDataStream* request_body,
                   HttpResponseInfo* response,
-                  OldCompletionCallback* callback);
+                  const CompletionCallback& callback);
 
   int ReadResponseHeaders(int pipeline_id,
-                          OldCompletionCallback* callback);
+                          const CompletionCallback& callback);
 
   int ReadResponseBody(int pipeline_id,
                        IOBuffer* buf, int buf_len,
-                       OldCompletionCallback* callback);
+                       const CompletionCallback& callback);
 
   void Close(int pipeline_id,
              bool not_reusable);
 
   uint64 GetUploadProgress(int pipeline_id) const;
 
   HttpResponseInfo* GetResponseInfo(int pipeline_id);
 
   bool IsResponseBodyComplete(int pipeline_id) const;
 
@@ skipping 48 matching lines @@
 
   struct PendingSendRequest {
     PendingSendRequest();
     ~PendingSendRequest();
 
     int pipeline_id;
     std::string request_line;
     HttpRequestHeaders headers;
     UploadDataStream* request_body;
     HttpResponseInfo* response;
-    OldCompletionCallback* callback;
+    CompletionCallback callback;
   };
 
   struct StreamInfo {
     StreamInfo();
     ~StreamInfo();
 
     linked_ptr<HttpStreamParser> parser;
-    OldCompletionCallback* read_headers_callback;
-    OldCompletionCallback* pending_user_callback;
+    CompletionCallback read_headers_callback;
+    CompletionCallback pending_user_callback;
     StreamState state;
   };
 
   typedef std::map<int, StreamInfo> StreamInfoMap;
 
   // Called after the first request is sent or in a task sometime after the
   // first stream is added to this pipeline. This gives the first request
   // priority to send, but doesn't hold up other requests if it doesn't.
   // When called the first time, notifies the |delegate_| that we can accept new
   // requests.
@@ skipping 75 matching lines @@
   // every time we receive headers.
   void CheckHeadersForPipelineCompatibility(int result, int pipeline_id);
 
   // Posts a task to fire the user's callback in response to SendRequest() or
   // ReadResponseHeaders() completing on an underlying parser. This might be
   // invoked in response to our own IO callbacks, or it may be invoked if the
   // underlying parser completes SendRequest() or ReadResponseHeaders()
   // synchronously, but we've already returned ERR_IO_PENDING to the user's
   // SendRequest() or ReadResponseHeaders() call into us.
   void QueueUserCallback(int pipeline_id,
-                         OldCompletionCallback* callback,
+                         const CompletionCallback& callback,
                          int rv,
                          const tracked_objects::Location& from_here);
 
   // Invokes the callback queued in QueueUserCallback().
   void FireUserCallback(int pipeline_id, int result);
 
   Delegate* delegate_;
   scoped_ptr<ClientSocketHandle> connection_;
   SSLConfig used_ssl_config_;
   ProxyInfo used_proxy_info_;
   BoundNetLog net_log_;
   bool was_npn_negotiated_;
   scoped_refptr<GrowableIOBuffer> read_buf_;
   int next_pipeline_id_;
   bool active_;
   bool usable_;
   bool completed_one_request_;
-  ScopedRunnableMethodFactory<HttpPipelinedConnectionImpl> method_factory_;
+  base::WeakPtrFactory<HttpPipelinedConnectionImpl> weak_factory_;
 
   StreamInfoMap stream_info_map_;
 
   std::queue<int> request_order_;
 
   std::queue<PendingSendRequest*> pending_send_request_queue_;
   scoped_ptr<PendingSendRequest> active_send_request_;
   SendRequestState send_next_state_;
   bool send_still_on_call_stack_;
-  OldCompletionCallbackImpl<HttpPipelinedConnectionImpl> send_io_callback_;
 
   ReadHeadersState read_next_state_;
   int active_read_id_;
   bool read_still_on_call_stack_;
-  OldCompletionCallbackImpl<HttpPipelinedConnectionImpl> read_io_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpPipelinedConnectionImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_PIPELINED_CONNECTION_IMPL_H_