Keeping track of whether WebKit is in the callstack using RenderThread doesn'...

chrome/renderer/render_widget.cc

 // Copyright (c) 2006-2008 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/renderer/render_widget.h"
 
 #include "base/gfx/point.h"
 #include "base/gfx/size.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/transport_dib.h"
 #include "chrome/renderer/render_process.h"
 #include "skia/ext/platform_canvas.h"
 
 #if defined(OS_POSIX)
 #include "skia/include/SkPixelRef.h"
 #include "skia/include/SkMallocPixelRef.h"
 #endif  // defined(OS_POSIX)
 
 #include "webkit/glue/webinputevent.h"
 #include "webkit/glue/webwidget.h"
 
-///////////////////////////////////////////////////////////////////////////////
-
-namespace {
-
-// This class is used to defer calling RenderWidget::Close() while the current
-// thread is inside RenderThread::Send(), which in some cases can result in a
-// nested MessageLoop being run.
-class DeferredCloses : public Task {
- public:
-  // Called to queue a deferred close for the given widget.
-  static void Push(RenderWidget* widget) {
-    if (!current_)
-      current_ = new DeferredCloses();
-    current_->queue_.push(widget);
-  }
-
-  // Called to trigger any deferred closes to be run.
-  static void Post() {
-    if (current_) {
-      MessageLoop::current()->PostTask(FROM_HERE, current_);
-      current_ = NULL;
-    }
-  }
-
- private:
-  virtual void Run() {
-    // Maybe we are being run from within another RenderWidget::Send call.  If
-    // that is true, then we need to re-queue the widgets to be closed and try
-    // again later.
-    while (!queue_.empty()) {
-      if (queue_.front()->InSend()) {
-        Push(queue_.front());
-      } else {
-        queue_.front()->Close();
-      }
-      queue_.pop();
-    }
-  }
-
-  // The current DeferredCloses object.
-  static DeferredCloses* current_;
-
-  typedef std::queue< scoped_refptr<RenderWidget> > WidgetQueue;
-  WidgetQueue queue_;
-};
-
-DeferredCloses* DeferredCloses::current_ = NULL;
-
-}  // namespace
-
-///////////////////////////////////////////////////////////////////////////////
-
 RenderWidget::RenderWidget(RenderThreadBase* render_thread, bool activatable)
     : routing_id_(MSG_ROUTING_NONE),
       webwidget_(NULL),
       opener_id_(MSG_ROUTING_NONE),
       render_thread_(render_thread),
       host_window_(NULL),
       current_paint_buf_(NULL),
       current_scroll_buf_(NULL),
       next_paint_flags_(0),
       paint_reply_pending_(false),
@@ skipping 90 matching lines @@
   // Don't send any messages after the browser has told us to close.
   if (closing_) {
     delete message;
     return false;
   }
 
   // If given a messsage without a routing ID, then assign our routing ID.
   if (message->routing_id() == MSG_ROUTING_NONE)
     message->set_routing_id(routing_id_);
 
-  bool rv = render_thread_->Send(message);
-
-  // If there aren't any more RenderThread::Send calls on the stack, then we
-  // can go ahead and schedule Close to be called on any RenderWidget objects
-  // that received a ViewMsg_Close while we were inside Send.
-  if (!render_thread_->InSend())
-    DeferredCloses::Post();
-
-  return rv;
-}
-
-bool RenderWidget::InSend() const {
-  return render_thread_->InSend();
+  return render_thread_->Send(message);
 }
 
 // Got a response from the browser after the renderer decided to create a new
 // view.
 void RenderWidget::OnCreatingNewAck(gfx::NativeViewId parent) {
   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 
   CompleteInit(parent);
 }
 
 void RenderWidget::OnClose() {
   if (closing_)
     return;
   closing_ = true;
 
   // Browser correspondence is no longer needed at this point.
   if (routing_id_ != MSG_ROUTING_NONE)
     render_thread_->RemoveRoute(routing_id_);
 
-  // Balances the AddRef taken when we called AddRoute.  This release happens
-  // via the MessageLoop since it may cause our destruction.
-  MessageLoop::current()->ReleaseSoon(FROM_HERE, this);
+  // If there is a Send call on the stack, then it could be dangerous to close
+  // now.  Post a task that only gets invoked when there are no nested message
+  // loops.
+  MessageLoop::current()->PostNonNestableTask(FROM_HERE,
+      NewRunnableMethod(this, &RenderWidget::Close));
 
-  // If there is a Send call on the stack, then it could be dangerous to close
-  // now.  Instead, we wait until we get out of Send.
-  if (render_thread_->InSend()) {
-    DeferredCloses::Push(this);
-  } else {
-    Close();
-  }
+  // Balances the AddRef taken when we called AddRoute.
+  Release();
 }
 
 void RenderWidget::OnResize(const gfx::Size& new_size,
                             const gfx::Rect& resizer_rect) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   // Remember the rect where the resize corner will be drawn.
   resizer_rect_ = resizer_rect;
@@ skipping 563 matching lines @@
   for (; i < plugin_window_moves_.size(); ++i) {
     if (plugin_window_moves_[i].window == move.window) {
       plugin_window_moves_[i] = move;
       break;
     }
   }
 
   if (i == plugin_window_moves_.size())
     plugin_window_moves_.push_back(move);
 }