WaitableEvent

chrome/browser/render_view_host.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/browser/render_view_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_util.h"
+#include "base/waitable_event.h"
 #include "chrome/app/result_codes.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/cross_site_request_manager.h"
 #include "chrome/browser/navigation_entry.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/render_process_host.h"
 #include "chrome/browser/render_widget_host.h"
 #include "chrome/browser/render_widget_host_view.h"
 #include "chrome/browser/render_view_host_delegate.h"
 #include "chrome/browser/renderer_security_policy.h"
@@ skipping 46 matching lines @@
   RenderWidgetHost* widget = static_cast<RenderWidgetHost*>(
       process->GetListenerByID(render_view_id));
   if (!widget || !widget->IsRenderView())
     return NULL;
   return static_cast<RenderViewHost*>(widget);
 }
 
 RenderViewHost::RenderViewHost(SiteInstance* instance,
                                RenderViewHostDelegate* delegate,
                                int routing_id,
-                               HANDLE modal_dialog_event)
+                               base::WaitableEvent* modal_dialog_event)
     : RenderWidgetHost(instance->GetProcess(), routing_id),
       instance_(instance),
       enable_dom_ui_bindings_(false),
       enable_external_host_bindings_(false),
       delegate_(delegate),
       renderer_initialized_(false),
       waiting_for_drag_context_response_(false),
       debugger_attached_(false),
       modal_dialog_count_(0),
       navigations_suspended_(false),
       suspended_nav_message_(NULL),
       run_modal_reply_msg_(NULL),
       has_unload_listener_(false),
       is_waiting_for_unload_ack_(false),
       are_javascript_messages_suppressed_(false) {
   DCHECK(instance_);
   DCHECK(delegate_);
   if (modal_dialog_event == NULL)
-    modal_dialog_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+    modal_dialog_event = new base::WaitableEvent(true, false);
 
-  modal_dialog_event_.Set(modal_dialog_event);
+  modal_dialog_event_.reset(modal_dialog_event);
 #ifdef CHROME_PERSONALIZATION
   personalization_ = Personalization::CreateHostPersonalization(this);
 #endif
 }
 
 RenderViewHost::~RenderViewHost() {
   OnDebugDisconnect();
 
 #ifdef CHROME_PERSONALIZATION
   Personalization::CleanupHostPersonalization(personalization_);
@@ skipping 18 matching lines @@
   DCHECK(process_->profile());
 
   renderer_initialized_ = true;
 
   HANDLE modal_dialog_event;
   HANDLE renderer_process_handle = process()->process().handle();
   if (renderer_process_handle == NULL)
     renderer_process_handle = GetCurrentProcess();
 
   BOOL result = DuplicateHandle(GetCurrentProcess(),
-      modal_dialog_event_.Get(),
+      modal_dialog_event_->handle(),
       renderer_process_handle,
       &modal_dialog_event,
       SYNCHRONIZE,
       FALSE,
       0);
   DCHECK(result) << "Couldn't duplicate the modal dialog handle for the renderer.";
 
   DCHECK(view_);
   Send(new ViewMsg_New(view_->GetPluginHWND(),
                        modal_dialog_event,
@@ skipping 343 matching lines @@
   if (is_waiting_for_unload_ack_) {
     if (are_javascript_messages_suppressed_) {
       delegate_->RendererUnresponsive(this, is_waiting_for_unload_ack_);
       return;
     }
 
     StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
   }
 
   if (--modal_dialog_count_ == 0)
-    ResetEvent(modal_dialog_event_.Get());
+    modal_dialog_event_->Reset();
   ViewHostMsg_RunJavaScriptMessage::WriteReplyParams(reply_msg, success, prompt);
   Send(reply_msg);
 }
 
 void RenderViewHost::ModalHTMLDialogClosed(IPC::Message* reply_msg,
                                            const std::string& json_retval) {
   if (is_waiting_for_unload_ack_)
     StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
 
   if (--modal_dialog_count_ == 0)
-    ResetEvent(modal_dialog_event_.Get());
+    modal_dialog_event_->Reset();
 
   ViewHostMsg_ShowModalHTMLDialog::WriteReplyParams(reply_msg, json_retval);
   Send(reply_msg);
 }
 
 void RenderViewHost::CopyImageAt(int x, int y) {
   Send(new ViewMsg_CopyImageAt(routing_id_, x, y));
 }
 
 void RenderViewHost::InspectElementAt(int x, int y) {
@@ skipping 212 matching lines @@
     // The message had a handler, but its de-serialization failed.
     // Kill the renderer.
     process()->ReceivedBadMessage(msg.type());
   }
 }
 
 void RenderViewHost::Shutdown() {
   // If we are being run modally (see RunModal), then we need to cleanup.
   if (run_modal_reply_msg_) {
     if (--modal_dialog_count_ == 0)
-      ResetEvent(modal_dialog_event_.Get());
+      modal_dialog_event_->Reset();
     Send(run_modal_reply_msg_);
     run_modal_reply_msg_ = NULL;
   }
   RenderWidgetHost::Shutdown();
 }
 
 void RenderViewHost::OnMsgCreateWindow(int route_id,
                                        HANDLE modal_dialog_event) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
-    view->CreateNewWindow(route_id, modal_dialog_event);
+    view->CreateNewWindow(route_id,
+                          new base::WaitableEvent(modal_dialog_event));
 }
 
 void RenderViewHost::OnMsgCreateWidget(int route_id, bool activatable) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
     view->CreateNewWidget(route_id, activatable);
 }
 
 void RenderViewHost::OnMsgShowView(int route_id,
                                    WindowOpenDisposition disposition,
                                    const gfx::Rect& initial_pos,
                                    bool user_gesture) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
     view->ShowCreatedWindow(route_id, disposition, initial_pos, user_gesture);
 }
 
 void RenderViewHost::OnMsgShowWidget(int route_id,
                                      const gfx::Rect& initial_pos) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
     view->ShowCreatedWidget(route_id, initial_pos);
 }
 
 void RenderViewHost::OnMsgRunModal(IPC::Message* reply_msg) {
   DCHECK(!run_modal_reply_msg_);
   if (modal_dialog_count_++ == 0)
-    SetEvent(modal_dialog_event_.Get());
+    modal_dialog_event_->Reset();
   run_modal_reply_msg_ = reply_msg;
 
   // TODO(darin): Bug 1107929: Need to inform our delegate to show this view in
   // an app-modal fashion.
 }
 
 void RenderViewHost::OnMsgRendererReady() {
   WasResized();
   delegate_->RendererReady(this);
 }
@@ skipping 283 matching lines @@
   delegate_->RunFileChooser(multiple_files, title, default_file, real_filter);
 }
 
 void RenderViewHost::OnMsgRunJavaScriptMessage(
     const std::wstring& message,
     const std::wstring& default_prompt,
     const int flags,
     IPC::Message* reply_msg) {
   StopHangMonitorTimeout();
   if (modal_dialog_count_++ == 0)
-    SetEvent(modal_dialog_event_.Get());
+    modal_dialog_event_->Signal();
   bool did_suppress_message = false;
   delegate_->RunJavaScriptMessage(message, default_prompt, flags, reply_msg,
                                   &are_javascript_messages_suppressed_);
 }
 
 void RenderViewHost::OnMsgRunBeforeUnloadConfirm(const std::wstring& message,
                                                  IPC::Message* reply_msg) {
   StopHangMonitorTimeout();
   if (modal_dialog_count_++ == 0)
-    SetEvent(modal_dialog_event_.Get());
+    modal_dialog_event_->Signal();
   delegate_->RunBeforeUnloadConfirm(message, reply_msg);
 }
 
 void RenderViewHost::OnMsgShowModalHTMLDialog(
     const GURL& url, int width, int height, const std::string& json_arguments,
     IPC::Message* reply_msg) {
   StopHangMonitorTimeout();
   if (modal_dialog_count_++ == 0)
-    SetEvent(modal_dialog_event_.Get());
+    modal_dialog_event_->Signal();
   delegate_->ShowModalHTMLDialog(url, width, height, json_arguments, reply_msg);
 }
 
 void RenderViewHost::OnMsgPasswordFormsSeen(
     const std::vector<PasswordForm>& forms) {
   delegate_->PasswordFormsSeen(forms);
 }
 
 void RenderViewHost::OnMsgAutofillFormSubmitted(
     const AutofillForm& form) {
@@ skipping 182 matching lines @@
   Send(new ViewMsg_PersonalizationEvent(routing_id_,
                                         event_name,
                                         event_arg));
 }
 #endif
 
 void RenderViewHost::ForwardMessageFromExternalHost(
     const std::string& target, const std::string& message) {
   Send(new ViewMsg_HandleMessageFromExternalHost(routing_id_, target, message));
 }