WaitableEvent

chrome/renderer/render_view.h

 // 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.
 
 #ifndef CHROME_RENDERER_RENDER_VIEW_H_
 #define CHROME_RENDERER_RENDER_VIEW_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 30 matching lines @@
 class GURL;
 class RenderThread;
 class SkBitmap;
 struct ThumbnailScore;
 class WebError;
 class WebFrame;
 class WebPluginDelegate;
 class WebPluginDelegateProxy;
 enum WebRequestCachePolicy;
 
+namespace base {
+class WaitableEvent;
+}
+
 namespace webkit_glue {
 struct FileUploadData;
 }
 
 // We need to prevent a page from trying to create infinite popups. It is not
 // as simple as keeping a count of the number of immediate children
 // popups. Having an html file that window.open()s itself would create
 // an unlimited chain of RenderViews who only have one RenderView child.
 //
 // Therefore, each new top level RenderView creates a new counter and shares it
@@ skipping 17 matching lines @@
   // parent of the WebView HWND that will be created.  The modal_dialog_event
   // is set by the RenderView whenever a modal dialog alert is shown, so that
   // the renderer and plugin processes know to pump window messages.  If this
   // is a constrained popup or as a new tab, opener_id is the routing ID of the
   // RenderView responsible for creating this RenderView (corresponding to the
   // parent_hwnd). |counter| is either a currently initialized counter, or NULL
   // (in which case we treat this RenderView as a top level window).
   static RenderView* Create(
       RenderThreadBase* render_thread,
       HWND parent_hwnd,
-      HANDLE modal_dialog_event,
+      base::WaitableEvent* modal_dialog_event,  // takes ownership
       int32 opener_id,
       const WebPreferences& webkit_prefs,
       SharedRenderViewCounter* counter,
       int32 routing_id);
 
   // Sets the "next page id" counter.
   static void SetNextPageID(int32 next_page_id);
 
   // The resource dispatcher used to fetch resources for this view.
   ResourceDispatcher* resource_dispatcher() {
     return resource_dispatcher_;
   }
 
   // May return NULL when the view is closing.
   WebView* webview() const {
     return static_cast<WebView*>(webwidget());
   }
 
   HWND host_window() const {
     return host_window_;
   }
 
-  HANDLE modal_dialog_event() {
-    return modal_dialog_event_.Get();
+  base::WaitableEvent* modal_dialog_event() {
+    return modal_dialog_event_.get();
   }
 
   // IPC::Channel::Listener
   virtual void OnMessageReceived(const IPC::Message& msg);
 
   // WebViewDelegate
   virtual void ShowModalHTMLDialog(const GURL& url, int width, int height,
                                    const std::string& json_arguments,
                                    std::string* json_retval);
   virtual void RunJavaScriptAlert(WebView* webview,
@@ skipping 198 matching lines @@
  private:
   FRIEND_TEST(RenderViewTest, OnLoadAlternateHTMLText);
   FRIEND_TEST(RenderViewTest, OnNavStateChanged);
 
   explicit RenderView(RenderThreadBase* render_thread);
 
   // Initializes this view with the given parent and ID. The |routing_id| can be
   // set to 'MSG_ROUTING_NONE' if the true ID is not yet known. In this case,
   // CompleteInit must be called later with the true ID.
   void Init(HWND parent,
-            HANDLE modal_dialog_event,
+            base::WaitableEvent* modal_dialog_event,  // takes ownership
             int32 opener_id,
             const WebPreferences& webkit_prefs,
             SharedRenderViewCounter* counter,
             int32 routing_id);
 
   void UpdateURL(WebFrame* frame);
   void UpdateTitle(WebFrame* frame, const std::wstring& title);
   void UpdateSessionHistory(WebFrame* frame);
 
   // Update current main frame's encoding and send it to browser window.
@@ skipping 310 matching lines @@
   WebPluginDelegate* first_default_plugin_;
 
   // If the browser hasn't sent us an ACK for the last FindReply we sent
   // to it, then we need to queue up the message (keeping only the most
   // recent message if new ones come in).
   scoped_ptr<IPC::Message> queued_find_reply_message_;
 
   // Handle to an event that's set when the page is showing a modal dialog (or
   // equivalent constrained window).  The renderer and any plugin processes
   // check this to know if they should pump messages/tasks then.
-  ScopedHandle modal_dialog_event_;
+  scoped_ptr<base::WaitableEvent> modal_dialog_event_;
 
   // Document width when in print CSS media type. 0 otherwise.
   int printed_document_width_;
 
   // Backup the view size before printing since it needs to be overriden. This
   // value is set to restore the view size when printing is done.
   gfx::Size printing_view_size_;
 
   scoped_refptr<DebugMessageHandler> debug_message_handler_;
 
@@ skipping 53 matching lines @@
   // Time in seconds of the delay between syncing page state such as form
   // elements and scroll position. This timeout allows us to avoid spamming the
   // browser process with every little thing that changes. This normally doesn't
   // change but is overridden by tests.
   int delay_seconds_for_form_state_sync_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderView);
 };
 
 #endif  // CHROME_RENDERER_RENDER_VIEW_H_