Revert 121901 - PPAPI: Add unlocking for PPP calls and callbacks. Add more locking.

ppapi/proxy/plugin_dispatcher.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "ppapi/proxy/plugin_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_channel.h"
 #include "base/debug/trace_event.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/proxy/interface_list.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/plugin_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_cursor_control_proxy.h"
 #include "ppapi/proxy/ppb_font_proxy.h"
 #include "ppapi/proxy/ppb_instance_proxy.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
 #include "ppapi/proxy/resource_creation_proxy.h"
-#include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 
 #if defined(OS_POSIX)
 #include "base/eintr_wrapper.h"
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, PluginDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
 typedef std::set<PluginDispatcher*> DispatcherSet;
 DispatcherSet* g_live_dispatchers = NULL;
 
 }  // namespace
 
 InstanceData::InstanceData()
     : flash_fullscreen(PP_FALSE),
       mouse_lock_callback(PP_BlockUntilComplete()) {
 }
 
 InstanceData::~InstanceData() {
   // Run any pending mouse lock callback to prevent leaks.
-  if (mouse_lock_callback.func) {
-    CallWhileUnlocked(PP_RunAndClearCompletionCallback,
-                      &mouse_lock_callback,
-                      static_cast<int32_t>(PP_ERROR_ABORTED));
-  }
+  if (mouse_lock_callback.func)
+    PP_RunAndClearCompletionCallback(&mouse_lock_callback, PP_ERROR_ABORTED);
 }
 
 PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
                                    GetInterfaceFunc get_interface)
     : Dispatcher(remote_process_handle, get_interface),
       plugin_delegate_(NULL),
       received_preferences_(false),
       plugin_dispatcher_id_(0) {
   SetSerializationRules(new PluginVarSerializationRules);
 
@@ skipping 90 matching lines @@
 
 bool PluginDispatcher::IsPlugin() const {
   return true;
 }
 
 bool PluginDispatcher::Send(IPC::Message* msg) {
   TRACE_EVENT2("ppapi proxy", "PluginDispatcher::Send",
                "Class", IPC_MESSAGE_ID_CLASS(msg->type()),
                "Line", IPC_MESSAGE_ID_LINE(msg->type()));
   // We always want plugin->renderer messages to arrive in-order. If some sync
-  // and some async messages are sent in response to a synchronous
+  // and some async messages are send in response to a synchronous
   // renderer->plugin call, the sync reply will be processed before the async
   // reply, and everything will be confused.
   //
   // Allowing all async messages to unblock the renderer means more reentrancy
   // there but gives correct ordering.
   msg->set_unblock(true);
-  if (msg->is_sync()) {
-    // Synchronous messages might be re-entrant, so we need to drop the lock.
-    ProxyAutoUnlock unlock;
-    return Dispatcher::Send(msg);
-  }
   return Dispatcher::Send(msg);
 }
 
 bool PluginDispatcher::OnMessageReceived(const IPC::Message& msg) {
-  // We need to grab the proxy lock to ensure that we don't collide with the
-  // plugin making pepper calls on a different thread.
-  ProxyAutoLock lock;
   TRACE_EVENT2("ppapi proxy", "PluginDispatcher::OnMessageReceived",
                "Class", IPC_MESSAGE_ID_CLASS(msg.type()),
                "Line", IPC_MESSAGE_ID_LINE(msg.type()));
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Handle some plugin-specific control messages.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(PluginDispatcher, msg)
       IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface)
       IPC_MESSAGE_HANDLER(PpapiMsg_SetPreferences, OnMsgSetPreferences)
       IPC_MESSAGE_UNHANDLED(handled = false);
@@ skipping 89 matching lines @@
   // once they're set. The user will have to restart to get new font prefs
   // propogated to plugins.
   if (!received_preferences_) {
     received_preferences_ = true;
     preferences_ = prefs;
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi