chrome: Use base::MessageLoop. (Part 3)

chrome/browser/chromeos/web_socket_proxy.cc

 // Copyright (c) 2012 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 419 matching lines @@
 
   // Used to schedule a timeout for initial phase of connection.
   scoped_ptr<struct event> destconnect_timeout_event_;
 
   static base::LazyInstance<EventKeyMap>::Leaky evkey_map_;
   static EventKey last_evkey_;
 
   DISALLOW_COPY_AND_ASSIGN(Conn);
 };
 
-class SSLChan : public MessageLoopForIO::Watcher {
+class SSLChan : public base::MessageLoopForIO::Watcher {
  public:
   static void Start(const net::AddressList& address_list,
                     const net::HostPortPair& host_port_pair,
                     int read_pipe,
                     int write_pipe) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     SSLChan* ALLOW_UNUSED chan = new SSLChan(
         address_list, host_port_pair, read_pipe, write_pipe);
   }
 
@@ skipping 127 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(
+          base::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);
+      base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
     }
   }
 
   void OnSocketConnect(int result) {
     if (phase_ != PHASE_CONNECTING) {
       NOTREACHED();
       return;
     }
     if (result) {
       Shut(result);
@@ skipping 22 matching lines @@
 
   void OnSSLHandshakeCompleted(int result) {
     if (result) {
       Shut(result);
       return;
     }
     is_socket_read_pending_ = false;
     is_socket_write_pending_ = false;
     is_read_pipe_blocked_ = false;
     is_write_pipe_blocked_ = false;
-    MessageLoopForIO::current()->WatchFileDescriptor(
-        read_pipe_, false, MessageLoopForIO::WATCH_READ,
-        &read_pipe_controller_, this);
-    MessageLoopForIO::current()->WatchFileDescriptor(
-        write_pipe_, false, MessageLoopForIO::WATCH_WRITE,
-        &write_pipe_controller_, this);
+    base::MessageLoopForIO::current()->WatchFileDescriptor(
+        read_pipe_,
+        false,
+        base::MessageLoopForIO::WATCH_READ,
+        &read_pipe_controller_,
+        this);
+    base::MessageLoopForIO::current()->WatchFileDescriptor(
+        write_pipe_,
+        false,
+        base::MessageLoopForIO::WATCH_WRITE,
+        &write_pipe_controller_,
+        this);
     phase_ = PHASE_RUNNING;
     Proceed();
   }
 
   void OnSocketRead(int result) {
     DCHECK(is_socket_read_pending_);
     is_socket_read_pending_ = false;
     if (result <= 0) {
       Shut(result);
       return;
@@ skipping 42 matching lines @@
       if (!is_read_pipe_blocked_ && phase_ == PHASE_RUNNING) {
         scoped_refptr<net::IOBufferWithSize> buf =
             outbound_stream_.GetIOBufferToFill();
         if (buf && buf->size() > 0) {
           int rv = read(read_pipe_, buf->data(), buf->size());
           if (rv > 0) {
             outbound_stream_.DidFill(rv);
             proceed = true;
           } else if (rv == -1 && errno == EAGAIN) {
             is_read_pipe_blocked_ = true;
-            MessageLoopForIO::current()->WatchFileDescriptor(
-                read_pipe_, false, MessageLoopForIO::WATCH_READ,
-                &read_pipe_controller_, this);
+            base::MessageLoopForIO::current()->WatchFileDescriptor(

[brettw, 2013/04/28 04:26:27]

I wouldn't have changed the wrapping for the cases in this file.

+                read_pipe_,
+                false,
+                base::MessageLoopForIO::WATCH_READ,
+                &read_pipe_controller_,
+                this);
           } else if (rv == 0) {
             Shut(0);
           } else {
             DCHECK_LT(rv, 0);
             Shut(net::ERR_UNEXPECTED);
             return;
           }
         }
       }
       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, base::Bind(&SSLChan::OnSocketRead,
-                                      weak_factory_.GetWeakPtr(), rv));
+            base::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, base::Bind(&SSLChan::OnSocketWrite,
-                                      weak_factory_.GetWeakPtr(), rv));
+            base::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());
           if (rv > 0) {
             inbound_stream_.DidProcess(rv);
             proceed = true;
           } else if (rv == -1 && errno == EAGAIN) {
             is_write_pipe_blocked_ = true;
-            MessageLoopForIO::current()->WatchFileDescriptor(
-                write_pipe_, false, MessageLoopForIO::WATCH_WRITE,
-                &write_pipe_controller_, this);
+            base::MessageLoopForIO::current()->WatchFileDescriptor(
+                write_pipe_,
+                false,
+                base::MessageLoopForIO::WATCH_WRITE,
+                &write_pipe_controller_,
+                this);
           } else {
             DCHECK_LE(rv, 0);
             inbound_stream_.Clear();
             Shut(net::ERR_UNEXPECTED);
             return;
           }
         } else if (phase_ == PHASE_CLOSING) {
           Shut(0);
         }
       }
     }
   }
 
   Phase phase_;
   scoped_ptr<net::StreamSocket> socket_;
   net::HostPortPair host_port_pair_;
   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_;
   base::WeakPtrFactory<SSLChan> weak_factory_;
-  MessageLoopForIO::FileDescriptorWatcher read_pipe_controller_;
-  MessageLoopForIO::FileDescriptorWatcher write_pipe_controller_;
+  base::MessageLoopForIO::FileDescriptorWatcher read_pipe_controller_;
+  base::MessageLoopForIO::FileDescriptorWatcher write_pipe_controller_;
 
   friend class base::DeleteHelper<SSLChan>;
   DISALLOW_COPY_AND_ASSIGN(SSLChan);
 };
 
 Serv::Serv()
     : evbase_(NULL),
       listening_sock_(-1),
       extra_listening_sock_(-1),
       shutdown_requested_(false) {
@@ skipping 1095 matching lines @@
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos