WaitableEvent

chrome/plugin/webplugin_proxy.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/plugin/webplugin_proxy.h"
 
 #include "base/gfx/gdi_util.h"
 #include "base/scoped_handle.h"
 #include "base/shared_memory.h"
 #include "base/singleton.h"
+#include "base/waitable_event.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/win_util.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "chrome/plugin/webplugin_delegate_stub.h"
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_util.h"
 #include "skia/ext/platform_device.h"
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 
@@ skipping 19 matching lines @@
 
   HANDLE event;
   BOOL result = DuplicateHandle(channel->renderer_handle(),
       modal_dialog_event,
       GetCurrentProcess(),
       &event,
       SYNCHRONIZE,
       FALSE,
       0);
   DCHECK(result) << "Couldn't duplicate the modal dialog handle for the plugin.";
-  modal_dialog_event_.Set(event);
+  modal_dialog_event_.reset(new base::WaitableEvent(event));
 }
 
 WebPluginProxy::~WebPluginProxy() {
   if (cp_browsing_context_)
     GetContextMap().erase(cp_browsing_context_);
 }
 
 bool WebPluginProxy::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
@@ skipping 53 matching lines @@
   bool success = false;
   void* npobject_ptr;
   Send(new PluginHostMsg_GetWindowScriptNPObject(
       route_id_, npobject_route_id, &success, &npobject_ptr));
   if (!success)
     return NULL;
 
   window_npobject_ = NPObjectProxy::Create(channel_,
                                            npobject_route_id,
                                            npobject_ptr,
-                                           modal_dialog_event_.Get());
+                                           modal_dialog_event_.get());
 
   return window_npobject_;
 }
 
 NPObject* WebPluginProxy::GetPluginElement() {
   if (plugin_element_)
     return NPN_RetainObject(plugin_element_);
 
   int npobject_route_id = channel_->GenerateRouteID();
   bool success = false;
   void* npobject_ptr;
   Send(new PluginHostMsg_GetPluginElement(
       route_id_, npobject_route_id, &success, &npobject_ptr));
   if (!success)
     return NULL;
 
   plugin_element_ = NPObjectProxy::Create(channel_,
                                           npobject_route_id,
                                           npobject_ptr,
-                                          modal_dialog_event_.Get());
+                                          modal_dialog_event_.get());
 
   return plugin_element_;
 }
 
 void WebPluginProxy::SetCookie(const GURL& url,
                                const GURL& policy_url,
                                const std::string& cookie) {
   Send(new PluginHostMsg_SetCookie(route_id_, url, policy_url, cookie));
 }
 
 std::string WebPluginProxy::GetCookies(const GURL& url,
                                        const GURL& policy_url) {
   std::string cookies;
   Send(new PluginHostMsg_GetCookies(route_id_, url, policy_url, &cookies));
 
   return cookies;
 }
 
 void WebPluginProxy::ShowModalHTMLDialog(const GURL& url, int width, int height,
                                          const std::string& json_arguments,
                                          std::string* json_retval) {
   PluginHostMsg_ShowModalHTMLDialog* msg =
       new PluginHostMsg_ShowModalHTMLDialog(
           route_id_, url, width, height, json_arguments, json_retval);
 
   // Create a new event and set it.  This forces us to pump messages while
   // waiting for a response (which won't come until the dialog is closed).  This
   // avoids a deadlock.
-  ScopedHandle event(CreateEvent(NULL, FALSE, TRUE, NULL));
-  msg->set_pump_messages_event(event);
+  scoped_ptr<base::WaitableEvent> event(
+      new base::WaitableEvent(false, true));
+  msg->set_pump_messages_event(event.get());
 
   Send(msg);
 }
 
 void WebPluginProxy::OnMissingPluginStatus(int status) {
   Send(new PluginHostMsg_MissingPluginStatus(route_id_, status));
 }
 
 CPBrowsingContext WebPluginProxy::GetCPBrowsingContext() {
   if (cp_browsing_context_ == 0) {
@@ skipping 200 matching lines @@
 
   Send(new PluginHostMsg_InitiateHTTPRangeRequest(route_id_, url,
                                                   range_info, existing_stream,
                                                   notify_needed, notify_data));
 }
 
 void WebPluginProxy::OnPaint(const gfx::Rect& damaged_rect) {
   Paint(damaged_rect);
   Send(new PluginHostMsg_InvalidateRect(route_id_, damaged_rect));
 }