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

ppapi/proxy/ppb_var_deprecated_proxy.cc

 // 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/ppb_var_deprecated_proxy.h"
 
 #include <stdlib.h>  // For malloc
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/plugin_var_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppb_var_shared.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // Used to do get the set-up information for calling a var object. If the
 // exception is set, returns NULL. Otherwise, computes the dispatcher for the
 // given var object. If the var is not a valid object, returns NULL and sets
@@ skipping 22 matching lines @@
         std::string("Attempting to use an invalid object"));
   }
   return NULL;
 }
 
 // PPB_Var_Deprecated plugin ---------------------------------------------------
 
 bool HasProperty(PP_Var var,
                  PP_Var name,
                  PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
   if (!dispatcher)
     return false;
 
   ReceiveSerializedException se(dispatcher, exception);
   PP_Bool result = PP_FALSE;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_HasProperty(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
   return PP_ToBool(result);
 }
 
 bool HasMethod(PP_Var var,
                PP_Var name,
                PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
   if (!dispatcher)
     return false;
 
   ReceiveSerializedException se(dispatcher, exception);
   PP_Bool result = PP_FALSE;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_HasMethodDeprecated(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
   return PP_ToBool(result);
 }
 
 PP_Var GetProperty(PP_Var var,
                    PP_Var name,
                    PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   ReceiveSerializedException se(dispatcher, exception);
   ReceiveSerializedVarReturnValue result;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_GetProperty(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
   return result.Return(dispatcher);
 }
 
 void EnumerateProperties(PP_Var var,
                          uint32_t* property_count,
                          PP_Var** properties,
                          PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
   if (!dispatcher) {
     *property_count = 0;
     *properties = NULL;
     return;
   }
 
   ReceiveSerializedVarVectorOutParam out_vector(dispatcher,
                                                 property_count, properties);
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_EnumerateProperties(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         out_vector.OutParam(), &se));
   }
 }
 
 void SetProperty(PP_Var var,
                  PP_Var name,
                  PP_Var value,
                  PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
   if (!dispatcher)
     return;
 
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_SetPropertyDeprecated(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name),
         SerializedVarSendInput(dispatcher, value), &se));
   }
 }
 
 void RemoveProperty(PP_Var var,
                     PP_Var name,
                     PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
   if (!dispatcher)
     return;
 
   ReceiveSerializedException se(dispatcher, exception);
   PP_Bool result = PP_FALSE;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_DeleteProperty(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
 }
 
 PP_Var Call(PP_Var object,
             PP_Var method_name,
             uint32_t argc,
             PP_Var* argv,
             PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(object, exception);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   ReceiveSerializedVarReturnValue result;
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     std::vector<SerializedVar> argv_vect;
     SerializedVarSendInput::ConvertVector(dispatcher, argv, argc, &argv_vect);
 
     dispatcher->Send(new PpapiHostMsg_PPBVar_CallDeprecated(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, object),
         SerializedVarSendInput(dispatcher, method_name), argv_vect,
         &se, &result));
   }
   return result.Return(dispatcher);
 }
 
 PP_Var Construct(PP_Var object,
                  uint32_t argc,
                  PP_Var* argv,
                  PP_Var* exception) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(object, exception);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   ReceiveSerializedVarReturnValue result;
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     std::vector<SerializedVar> argv_vect;
     SerializedVarSendInput::ConvertVector(dispatcher, argv, argc, &argv_vect);
 
     dispatcher->Send(new PpapiHostMsg_PPBVar_Construct(
         API_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, object),
         argv_vect, &se, &result));
   }
   return result.Return(dispatcher);
 }
 
 bool IsInstanceOf(PP_Var var,
                   const PPP_Class_Deprecated* ppp_class,
                   void** ppp_class_data) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, NULL);
   if (!dispatcher)
     return false;
 
   PP_Bool result = PP_FALSE;
   int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
   int64 class_data_int = 0;
   dispatcher->Send(new PpapiHostMsg_PPBVar_IsInstanceOfDeprecated(
       API_ID_PPB_VAR_DEPRECATED, SerializedVarSendInput(dispatcher, var),
       class_int, &class_data_int, &result));
   *ppp_class_data =
       reinterpret_cast<void*>(static_cast<intptr_t>(class_data_int));
   return PP_ToBool(result);
 }
 
 PP_Var CreateObject(PP_Instance instance,
                     const PPP_Class_Deprecated* ppp_class,
                     void* ppp_class_data) {
+  ProxyAutoLock lock;
   Dispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   ReceiveSerializedVarReturnValue result;
   int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
   int64 data_int =
       static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class_data));
   dispatcher->Send(new PpapiHostMsg_PPBVar_CreateObjectDeprecated(
       API_ID_PPB_VAR_DEPRECATED, instance, class_int, data_int,
@@ skipping 108 matching lines @@
   // release the object before it is AddRef'ed on the browser side.
   // To work around this, we post a task here, that will not execute before
   // control goes back to the main message loop, that will ensure the sync send
   // has returned and the browser side can take its reference before we Release.
   // Note: if the instance is gone by the time the task is executed, then it
   // will Release the objects itself and this Release will be a NOOP (aside of a
   // spurious warning).
   // TODO(piman): See if we can fix the IPC code to enforce strict ordering, and
   // then remove this.
   MessageLoop::current()->PostNonNestableTask(FROM_HERE,
-      base::Bind(&PPB_Var_Deprecated_Proxy::DoReleaseObject,
-                 task_factory_.GetWeakPtr(),
-                 object_id));
+      RunWhileLocked(base::Bind(&PPB_Var_Deprecated_Proxy::DoReleaseObject,
+                     task_factory_.GetWeakPtr(),
+                     object_id)));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgHasProperty(
     SerializedVarReceiveInput var,
     SerializedVarReceiveInput name,
     SerializedVarOutParam exception,
     PP_Bool* result) {
   SetAllowPluginReentrancy();
   *result = PP_FromBool(ppb_var_impl_->HasProperty(
       var.Get(dispatcher()),
@@ skipping 119 matching lines @@
 }
 
 void PPB_Var_Deprecated_Proxy::DoReleaseObject(int64 object_id) {
   PP_Var var = { PP_VARTYPE_OBJECT };
   var.value.as_id = object_id;
   ppb_var_impl_->Release(var);
 }
 
 }  // namespace proxy
 }  // namespace ppapi