base::Bind: Convert NewRunnableMethod in chrome/browser.

chrome/browser/chromeos/web_socket_proxy.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 "chrome/browser/chromeos/web_socket_proxy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 13 matching lines @@
 #include <sys/wait.h>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/chromeos/web_socket_proxy_helper.h"
 #include "chrome/browser/internal_auth.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 503 matching lines @@
   SSLChan(const net::AddressList address_list,
           const net::HostPortPair host_port_pair,
           int read_pipe,
           int write_pipe)
       : phase_(PHASE_CONNECTING),
         host_port_pair_(host_port_pair),
         inbound_stream_(WebSocketProxy::kBufferLimit),
         outbound_stream_(WebSocketProxy::kBufferLimit),
         read_pipe_(read_pipe),
         write_pipe_(write_pipe),
-        method_factory_(this) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
     if (!SetNonBlock(read_pipe_) || !SetNonBlock(write_pipe_)) {
       Shut(net::ERR_UNEXPECTED);
       return;
     }
     net::ClientSocketFactory* factory =
         net::ClientSocketFactory::GetDefaultFactory();
     socket_.reset(factory->CreateTransportClientSocket(
         address_list, NULL, net::NetLog::Source()));
     if (socket_ == NULL) {
       Shut(net::ERR_FAILED);
@@ skipping 15 matching lines @@
 
   void Shut(int ALLOW_UNUSED net_error_code) {
     if (phase_ != PHASE_CLOSED) {
       phase_ = PHASE_CLOSING;
       scoped_refptr<net::IOBufferWithSize> buf[] = {
           outbound_stream_.GetIOBufferToProcess(),
           inbound_stream_.GetIOBufferToProcess()
       };
       for (int i = arraysize(buf); i--;) {
         if (buf[i] && buf[i]->size() > 0) {
-          MessageLoop::current()->PostTask(FROM_HERE,
-              method_factory_.NewRunnableMethod(&SSLChan::Proceed));
+          MessageLoop::current()->PostTask(
+              FROM_HERE,
+              base::Bind(&SSLChan::Proceed, weak_factory_.GetWeakPtr()));
           return;
         }
       }
       phase_ = PHASE_CLOSED;
       if (socket_ != NULL) {
         socket_->Disconnect();
         socket_.reset();
       }
       MessageLoop::current()->DeleteSoon(FROM_HERE, this);
     }
@@ skipping 120 matching lines @@
       }
       if (!is_socket_read_pending_ && phase_ == PHASE_RUNNING) {
         scoped_refptr<net::IOBufferWithSize> buf =
             inbound_stream_.GetIOBufferToFill();
         if (buf && buf->size() > 0) {
           int rv = socket_->Read(
               buf, buf->size(),
               base::Bind(&SSLChan::OnSocketRead, base::Unretained(this)));
           is_socket_read_pending_ = true;
           if (rv != net::ERR_IO_PENDING) {
-            MessageLoop::current()->PostTask(FROM_HERE,
-                method_factory_.NewRunnableMethod(&SSLChan::OnSocketRead, rv));
+            MessageLoop::current()->PostTask(
+                FROM_HERE, base::Bind(&SSLChan::OnSocketRead,
+                                      weak_factory_.GetWeakPtr(), rv));
           }
         }
       }
       if (!is_socket_write_pending_) {
         scoped_refptr<net::IOBufferWithSize> buf =
             outbound_stream_.GetIOBufferToProcess();
         if (buf && buf->size() > 0) {
           int rv = socket_->Write(
               buf, buf->size(),
               base::Bind(&SSLChan::OnSocketWrite, base::Unretained(this)));
           is_socket_write_pending_ = true;
           if (rv != net::ERR_IO_PENDING) {
-            MessageLoop::current()->PostTask(FROM_HERE,
-                method_factory_.NewRunnableMethod(&SSLChan::OnSocketWrite, rv));
+            MessageLoop::current()->PostTask(
+                FROM_HERE, base::Bind(&SSLChan::OnSocketWrite,
+                                      weak_factory_.GetWeakPtr(), rv));
           }
         } else if (phase_ == PHASE_CLOSING) {
           Shut(0);
         }
       }
       if (!is_write_pipe_blocked_) {
         scoped_refptr<net::IOBufferWithSize> buf =
             inbound_stream_.GetIOBufferToProcess();
         if (buf && buf->size() > 0) {
           int rv = write(write_pipe_, buf->data(), buf->size());
@@ skipping 24 matching lines @@
   scoped_ptr<net::CertVerifier> cert_verifier_;
   net::SSLConfig ssl_config_;
   IOBufferQueue inbound_stream_;
   IOBufferQueue outbound_stream_;
   int read_pipe_;
   int write_pipe_;
   bool is_socket_read_pending_;
   bool is_socket_write_pending_;
   bool is_read_pipe_blocked_;
   bool is_write_pipe_blocked_;
-  ScopedRunnableMethodFactory<SSLChan> method_factory_;
+  base::WeakPtrFactory<SSLChan> weak_factory_;
   MessageLoopForIO::FileDescriptorWatcher read_pipe_controller_;
   MessageLoopForIO::FileDescriptorWatcher write_pipe_controller_;
 
   friend class DeleteTask<SSLChan>;
   DISALLOW_COPY_AND_ASSIGN(SSLChan);
 };
 
 Serv::Serv(const std::vector<std::string>& allowed_origins)
     : allowed_origins_(allowed_origins),
       evbase_(NULL),
@@ skipping 1105 matching lines @@
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos