Delay OnClose actions.

webkit/tools/test_shell/simple_socket_stream_bridge.cc

 // Copyright (c) 2009 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/message_loop.h"
 #include "base/ref_counted.h"
@@ skipping 40 matching lines @@
 
   // Runs on |g_io_thread|;
   void DoConnect(const GURL& url);
   void DoSend(std::vector<char>* data);
   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(webkit_glue::WebSocketStreamHandleDelegate* delegate);
+  void DoOnClose();
 
   int socket_id_;
   MessageLoop* message_loop_;
   WebKit::WebSocketStreamHandle* handle_;
   webkit_glue::WebSocketStreamHandleDelegate* delegate_;
 
   scoped_refptr<net::SocketStream> socket_;
+  // Number of pending tasks to handle net::SocketStream::Delegate methods.
+  int num_pending_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketStreamHandleBridgeImpl);
 };
 
 WebSocketStreamHandleBridgeImpl::WebSocketStreamHandleBridgeImpl(
     WebKit::WebSocketStreamHandle* handle,
     webkit_glue::WebSocketStreamHandleDelegate* delegate)
     : socket_id_(kNoSocketId),
       message_loop_(MessageLoop::current()),
       handle_(handle),
-      delegate_(delegate) {
+      delegate_(delegate),
+      num_pending_tasks_(0) {
 }
 
 WebSocketStreamHandleBridgeImpl::~WebSocketStreamHandleBridgeImpl() {
-  CHECK(socket_id_ == kNoSocketId);
+  DCHECK_EQ(socket_id_, kNoSocketId);
 }
 
 void WebSocketStreamHandleBridgeImpl::Connect(const GURL& url) {
-  CHECK(g_io_thread);
+  DCHECK(g_io_thread);
   AddRef();  // Released in DoOnClose().
   g_io_thread->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoConnect,
                         url));
   if (delegate_)
     delegate_->WillOpenStream(handle_, url);
 }
 
 bool WebSocketStreamHandleBridgeImpl::Send(
     const std::vector<char>& data) {
-  CHECK(g_io_thread);
+  DCHECK(g_io_thread);
   g_io_thread->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoSend,
                         new std::vector<char>(data)));
   return true;
 }
 
 void WebSocketStreamHandleBridgeImpl::Close() {
-  CHECK(g_io_thread);
+  DCHECK(g_io_thread);
   g_io_thread->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoClose));
 }
 
 void WebSocketStreamHandleBridgeImpl::OnConnected(
     net::SocketStream* socket, int max_pending_send_allowed) {
+  ++num_pending_tasks_;
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoOnConnected,
                         max_pending_send_allowed));
 }
 
 void WebSocketStreamHandleBridgeImpl::OnSentData(
     net::SocketStream* socket, int amount_sent) {
+  ++num_pending_tasks_;
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoOnSentData,
                         amount_sent));
 }
 
 void WebSocketStreamHandleBridgeImpl::OnReceivedData(
     net::SocketStream* socket, const char* data, int len) {
+  ++num_pending_tasks_;
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &WebSocketStreamHandleBridgeImpl::DoOnReceivedData,
                         new std::vector<char>(data, data + len)));
 }
 
 void WebSocketStreamHandleBridgeImpl::OnClose(net::SocketStream* socket) {
-  webkit_glue::WebSocketStreamHandleDelegate* delegate = delegate_;
-  delegate_ = NULL;
-  socket_ = 0;
+  ++num_pending_tasks_;
+  // Release socket_ on IO thread.
+  socket_ = NULL;
   socket_id_ = kNoSocketId;
   message_loop_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoOnClose,
-                        delegate));
+      NewRunnableMethod(this, &WebSocketStreamHandleBridgeImpl::DoOnClose));
 }
 
 void WebSocketStreamHandleBridgeImpl::DoConnect(const GURL& url) {
-  CHECK(MessageLoop::current() == g_io_thread);
+  DCHECK(MessageLoop::current() == g_io_thread);
   socket_ = new net::SocketStream(url, this);
   socket_->set_context(g_request_context);
   socket_->Connect();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoSend(std::vector<char>* data) {
-  CHECK(MessageLoop::current() == g_io_thread);
+  DCHECK(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() {
-  CHECK(MessageLoop::current() == g_io_thread);
+  DCHECK(MessageLoop::current() == g_io_thread);
   if (!socket_)
     return;
   socket_->Close();
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnConnected(
     int max_pending_send_allowed) {
-  CHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == message_loop_);
+  --num_pending_tasks_;
   if (delegate_)
     delegate_->DidOpenStream(handle_, max_pending_send_allowed);
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnSentData(int amount_sent) {
-  CHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == message_loop_);
+  --num_pending_tasks_;
   if (delegate_)
     delegate_->DidSendData(handle_, amount_sent);
 }
 
 void WebSocketStreamHandleBridgeImpl::DoOnReceivedData(
     std::vector<char>* data) {
-  CHECK(MessageLoop::current() == message_loop_);
+  DCHECK(MessageLoop::current() == message_loop_);
+  --num_pending_tasks_;
   scoped_ptr<std::vector<char> > scoped_data(data);
   if (delegate_)
     delegate_->DidReceiveData(handle_, &(data->at(0)), data->size());
 }
 
-void WebSocketStreamHandleBridgeImpl::DoOnClose(
-    webkit_glue::WebSocketStreamHandleDelegate* delegate) {
-  CHECK(MessageLoop::current() == message_loop_);
-  CHECK(!socket_);
+void WebSocketStreamHandleBridgeImpl::DoOnClose() {
+  DCHECK(MessageLoop::current() == message_loop_);
+  --num_pending_tasks_;
+  // 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();
 }
 
 }  // namespace
 
 /* static */
 void SimpleSocketStreamBridge::InitializeOnIOThread(
     URLRequestContext* request_context) {
   g_io_thread = MessageLoop::current();
   g_request_context = request_context;
 }
 
 void SimpleSocketStreamBridge::Cleanup() {
   g_io_thread = NULL;
   g_request_context = NULL;
 }
 
 namespace webkit_glue {
 
 /* static */
 WebSocketStreamHandleBridge* WebSocketStreamHandleBridge::Create(
     WebKit::WebSocketStreamHandle* handle,
     WebSocketStreamHandleDelegate* delegate) {
   return new WebSocketStreamHandleBridgeImpl(handle, delegate);
 }
 
 }  // namespace webkit_glue