webkit: Use base::MessageLoop.

webkit/tools/test_shell/simple_socket_stream_bridge.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 <vector>
 
 #include "webkit/tools/test_shell/simple_socket_stream_bridge.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
@@ skipping 49 matching lines @@
   void DoClose();
 
   // Runs on |message_loop_|;
   void DoOnConnected(int max_amount_send_allowed);
   void DoOnSentData(int amount_sent);
   void DoOnReceivedData(std::vector<char>* data);
   void DoOnClose();
   void DoOnError(int error_code, const char* error_msg);
 
   int socket_id_;
-  MessageLoop* message_loop_;
+  base::MessageLoop* message_loop_;
   WebKit::WebSocketStreamHandle* handle_;
   webkit_glue::WebSocketStreamHandleDelegate* delegate_;
 
   scoped_refptr<net::SocketStreamJob> socket_;
   // Number of pending tasks to handle net::SocketStream::Delegate methods.
   base::subtle::Atomic32 num_pending_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketStreamHandleBridgeImpl);
 };
 
 WebSocketStreamHandleBridgeImpl::WebSocketStreamHandleBridgeImpl(
     WebKit::WebSocketStreamHandle* handle,
     webkit_glue::WebSocketStreamHandleDelegate* delegate)
     : socket_id_(kNoSocketId),
-      message_loop_(MessageLoop::current()),
+      message_loop_(base::MessageLoop::current()),
       handle_(handle),
       delegate_(delegate),
       num_pending_tasks_(0) {
   net::WebSocketJob::EnsureInit();
 }
 
 WebSocketStreamHandleBridgeImpl::~WebSocketStreamHandleBridgeImpl() {
   DCHECK_EQ(socket_id_, kNoSocketId);
 }
 
@@ skipping 64 matching lines @@
 void WebSocketStreamHandleBridgeImpl::OnError(
     const net::SocketStream* socket, int error_code) {
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, 1);
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebSocketStreamHandleBridgeImpl::DoOnError, this,
                  error_code, net::ErrorToString(error_code)));
 }
 
 void WebSocketStreamHandleBridgeImpl::DoConnect(const GURL& url) {
-  DCHECK(MessageLoop::current() == g_io_thread);
+  DCHECK(base::MessageLoop::current() == g_io_thread);
   socket_ = net::SocketStreamJob::CreateSocketStreamJob(
-      url, this, g_request_context->transport_security_state(),
+      url,

[brettw, 2013/05/06 17:43:33]

Ditto.

[xhwang, 2013/05/07 00:11:07]

Done.

+      this,
+      g_request_context->transport_security_state(),
       g_request_context->ssl_config_service());
   socket_->set_context(g_request_context);
   socket_->Connect();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoSend(std::vector<char>* data) {
-  DCHECK(MessageLoop::current() == g_io_thread);
+  DCHECK(base::MessageLoop::current() == g_io_thread);
   scoped_ptr<std::vector<char> > scoped_data(data);
   if (!socket_)
     return;
   if (!socket_->SendData(&(data->at(0)), data->size()))
     socket_->Close();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoClose() {
-  DCHECK(MessageLoop::current() == g_io_thread);
+  DCHECK(base::MessageLoop::current() == g_io_thread);
   if (!socket_)
     return;
   socket_->Close();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnConnected(
     int max_pending_send_allowed) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(base::MessageLoop::current() == message_loop_);
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, -1);
   if (delegate_)
     delegate_->DidOpenStream(handle_, max_pending_send_allowed);
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnSentData(int amount_sent) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(base::MessageLoop::current() == message_loop_);
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, -1);
   if (delegate_)
     delegate_->DidSendData(handle_, amount_sent);
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnReceivedData(
     std::vector<char>* data) {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(base::MessageLoop::current() == message_loop_);
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, -1);
   scoped_ptr<std::vector<char> > scoped_data(data);
   if (delegate_)
     delegate_->DidReceiveData(handle_, &(data->at(0)), data->size());
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnClose() {
-  DCHECK(MessageLoop::current() == message_loop_);
+  DCHECK(base::MessageLoop::current() == message_loop_);
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, -1);
   // Don't handle OnClose if there are pending tasks.
   DCHECK_EQ(num_pending_tasks_, 0);
   DCHECK(!socket_);
   DCHECK_EQ(socket_id_, kNoSocketId);
   webkit_glue::WebSocketStreamHandleDelegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate)
     delegate->DidClose(handle_);
   Release();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnError(
     int error_code, const char* error_msg) {
   DCHECK(MessageLoop::current() == message_loop_);
   base::subtle::NoBarrier_AtomicIncrement(&num_pending_tasks_, -1);
   if (delegate_)
     delegate_->DidFail(handle_, error_code, ASCIIToUTF16(error_msg));
 }
 
 }  // namespace
 
 /* static */
 void SimpleSocketStreamBridge::InitializeOnIOThread(
     net::URLRequestContext* request_context) {
-  g_io_thread = MessageLoop::current();
+  g_io_thread = base::MessageLoop::current();
   g_request_context = request_context;
 }
 
 void SimpleSocketStreamBridge::Cleanup() {
   g_io_thread = NULL;
   g_request_context = NULL;
 }
 
 /* static */
 webkit_glue::WebSocketStreamHandleBridge* SimpleSocketStreamBridge::Create(
     WebKit::WebSocketStreamHandle* handle,
     webkit_glue::WebSocketStreamHandleDelegate* delegate) {
   return new WebSocketStreamHandleBridgeImpl(handle, delegate);
 }