Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

net/spdy/spdy_session.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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
@@ skipping 234 matching lines @@
 int SpdySession::trailing_ping_delay_time_ms_ = 1000;
 
 // static
 int SpdySession::hung_interval_ms_ = 10000;
 
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
                          HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          NetLog* net_log)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &SpdySession::OnReadComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &SpdySession::OnWriteComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       host_port_proxy_pair_(host_port_proxy_pair),
       spdy_session_pool_(spdy_session_pool),
       http_server_properties_(http_server_properties),
       connection_(new ClientSocketHandle),
       read_buffer_(new IOBuffer(kReadBufferSize)),
       read_pending_(false),
       stream_hi_water_mark_(1),  // Always start at 1 for the first stream id.
       write_pending_(false),
       delayed_write_pending_(false),
       is_secure_(false),
@@ skipping 151 matching lines @@
         int error = CreateStreamImpl(*pending_create.url,
                                      pending_create.priority,
                                      pending_create.spdy_stream,
                                      *pending_create.stream_net_log);
         scoped_refptr<SpdyStream>* stream = pending_create.spdy_stream;
         DCHECK(!ContainsKey(pending_callback_map_, stream));
         pending_callback_map_[stream] =
             CallbackResultPair(pending_create.callback, error);
         MessageLoop::current()->PostTask(
             FROM_HERE,
-            method_factory_.NewRunnableMethod(
-                &SpdySession::InvokeUserStreamCreationCallback, stream));
+            base::Bind(&SpdySession::InvokeUserStreamCreationCallback,
+                       weak_factory_.GetWeakPtr(), stream));
         break;
       }
     }
     if (no_pending_create_streams)
       return;  // there were no streams in any queue
   }
 }
 
 void SpdySession::CancelPendingCreateStreams(
     const scoped_refptr<SpdyStream>* spdy_stream) {
@@ skipping 307 matching lines @@
   if (read_pending_)
     return OK;
 
   if (state_ == CLOSED) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   CHECK(connection_.get());
   CHECK(connection_->socket());
-  int bytes_read = connection_->socket()->Read(read_buffer_.get(),
-                                               kReadBufferSize,
-                                               &read_callback_);
+  int bytes_read = connection_->socket()->Read(
+      read_buffer_.get(),
+      kReadBufferSize,
+      base::Bind(&SpdySession::OnReadComplete, base::Unretained(this)));
   switch (bytes_read) {
     case 0:
       // Socket is closed!
       CloseSessionOnError(ERR_CONNECTION_CLOSED, true);
       return ERR_CONNECTION_CLOSED;
     case net::ERR_IO_PENDING:
       // Waiting for data.  Nothing to do now.
       read_pending_ = true;
       return ERR_IO_PENDING;
     default:
       // Data was read, process it.
       // Schedule the work through the message loop to avoid recursive
       // callbacks.
       read_pending_ = true;
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &SpdySession::OnReadComplete, bytes_read));
+          base::Bind(&SpdySession::OnReadComplete,
+                     weak_factory_.GetWeakPtr(), bytes_read));
       break;
   }
   return OK;
 }
 
 void SpdySession::WriteSocketLater() {
   if (delayed_write_pending_)
     return;
 
   if (state_ < CONNECTED)
     return;
 
   delayed_write_pending_ = true;
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&SpdySession::WriteSocket));
+      base::Bind(&SpdySession::WriteSocket, weak_factory_.GetWeakPtr()));
 }
 
 void SpdySession::WriteSocket() {
   // This function should only be called via WriteSocketLater.
   DCHECK(delayed_write_pending_);
   delayed_write_pending_ = false;
 
   // If the socket isn't connected yet, just wait; we'll get called
   // again when the socket connection completes.  If the socket is
   // closed, just return.
@@ skipping 36 matching lines @@
         in_flight_write_ = SpdyIOBuffer(buffer, size, 0, next_buffer.stream());
       } else {
         size = uncompressed_frame.length() + spdy::SpdyFrame::kHeaderSize;
         in_flight_write_ = next_buffer;
       }
     } else {
       DCHECK(in_flight_write_.buffer()->BytesRemaining());
     }
 
     write_pending_ = true;
-    int rv = connection_->socket()->Write(in_flight_write_.buffer(),
-        in_flight_write_.buffer()->BytesRemaining(), &write_callback_);
+    int rv = connection_->socket()->Write(
+        in_flight_write_.buffer(),
+        in_flight_write_.buffer()->BytesRemaining(),
+        base::Bind(&SpdySession::OnWriteComplete, base::Unretained(this)));
     if (rv == net::ERR_IO_PENDING)
       break;
 
     // We sent the frame successfully.
     OnWriteComplete(rv);
 
     // TODO(mbelshe):  Test this error case.  Maybe we should mark the socket
     //                 as in an error state.
     if (rv < 0)
       break;
@@ skipping 724 matching lines @@
   WritePingFrame(next_ping_id_);
 }
 
 void SpdySession::PlanToSendTrailingPing() {
   if (trailing_ping_pending_)
     return;
 
   trailing_ping_pending_ = true;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&SpdySession::SendTrailingPing),
+      base::Bind(&SpdySession::SendTrailingPing, weak_factory_.GetWeakPtr()),
       trailing_ping_delay_time_ms_);
 }
 
 void SpdySession::SendTrailingPing() {
   DCHECK(trailing_ping_pending_);
   trailing_ping_pending_ = false;
   WritePingFrame(next_ping_id_);
 }
 
 void SpdySession::WritePingFrame(uint32 unique_id) {
@@ skipping 15 matching lines @@
   }
 }
 
 void SpdySession::PlanToCheckPingStatus() {
   if (check_ping_status_pending_)
     return;
 
   check_ping_status_pending_ = true;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &SpdySession::CheckPingStatus, base::TimeTicks::Now()),
+      base::Bind(&SpdySession::CheckPingStatus, weak_factory_.GetWeakPtr(),
+                 base::TimeTicks::Now()),
       hung_interval_ms_);
 }
 
 void SpdySession::CheckPingStatus(base::TimeTicks last_check_time) {
   // Check if we got a response back for all PINGs we had sent.
   if (pings_in_flight_ == 0) {
     check_ping_status_pending_ = false;
     return;
   }
 
@@ skipping 10 matching lines @@
     // Track all failed PING messages in a separate bucket.
     const base::TimeDelta kFailedPing =
         base::TimeDelta::FromInternalValue(INT_MAX);
     RecordPingRTTHistogram(kFailedPing);
     return;
   }
 
   // Check the status of connection after a delay.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&SpdySession::CheckPingStatus, now),
+      base::Bind(&SpdySession::CheckPingStatus, weak_factory_.GetWeakPtr(),
+                 now),
       delay.InMilliseconds());
 }
 
 void SpdySession::RecordPingRTTHistogram(base::TimeDelta duration) {
   UMA_HISTOGRAM_TIMES("Net.SpdyPing.RTT", duration);
 }
 
 void SpdySession::RecordHistograms() {
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdyStreamsPerSession",
                               streams_initiated_count_,
@@ skipping 76 matching lines @@
   if (it == pending_callback_map_.end())
     return;
 
   OldCompletionCallback* callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
   callback->Run(result);
 }
 
 }  // namespace net