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

ppapi/proxy/serialized_var_unittest.cc

 // Copyright (c) 2012 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/ppapi_proxy_test.h"
 
 #include "ppapi/proxy/serialized_var.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 PP_Var MakeObjectVar(int64_t object_id) {
   PP_Var ret;
   ret.type = PP_VARTYPE_OBJECT;
   ret.value.as_id = object_id;
   return ret;
 }
 
 class SerializedVarTest : public PluginProxyTest {
  public:
   SerializedVarTest() {}
 };
 
 }  // namespace
 
 // Tests output arguments in the plugin. This is when the host calls into the
 // plugin and the plugin returns something via an out param, like an exception.
 TEST_F(SerializedVarTest, PluginSerializedVarInOutParam) {
+  ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);
 
   PP_Var plugin_object;
   {
     // Receive the object param, we should be tracking it with no refcount, and
     // no messages sent.
     SerializedVarTestConstructor input(host_object);
     SerializedVarReceiveInput receive_input(input);
     plugin_object = receive_input.Get(plugin_dispatcher());
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
@@ skipping 29 matching lines @@
   // back to the host, so the object should no longer be in the tracker. The
   // reference we added has been removed, so another message should be sent to
   // the host to tell it we're done with the object.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(2u, sink().message_count());
 }
 
 // Tests output strings in the plugin. This is when the host calls into the
 // plugin with a string and the plugin returns it via an out param.
 TEST_F(SerializedVarTest, PluginSerializedStringVarInOutParam) {
+  ProxyAutoLock lock;
   PP_Var plugin_string;
   const std::string kTestString("elite");
   {
     // Receive the string param. We should track it with 1 refcount.
     SerializedVarTestConstructor input(kTestString);
     SerializedVarReceiveInput receive_input(input);
     plugin_string = receive_input.Get(plugin_dispatcher());
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_string));
     EXPECT_EQ(0u, sink().message_count());
 
@@ skipping 21 matching lines @@
   }
   // The reference the string had initially should be gone, and the reference we
   // passed to the host should also be gone, so the string should be removed.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_string));
   EXPECT_EQ(0u, sink().message_count());
 }
 
 // Tests receiving an argument and passing it back to the browser as an output
 // parameter.
 TEST_F(SerializedVarTest, PluginSerializedVarOutParam) {
+  ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);
 
   // Start tracking this object in the plugin.
   PP_Var plugin_object = var_tracker().ReceiveObjectPassRef(
       host_object, plugin_dispatcher());
   EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
 
   {
     SerializedVar sv;
     {
@@ skipping 19 matching lines @@
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(1u, sink().message_count());
 
   // We don't bother validating that message since it's nontrivial and the
   // PluginVarTracker test has cases that cover that this message is correct.
 }
 
 // Tests the case that the plugin receives the same var twice as an input
 // parameter (not passing ownership).
 TEST_F(SerializedVarTest, PluginReceiveInput) {
+  ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);
 
   PP_Var plugin_object;
   {
     // Receive the first param, we should be tracking it with no refcount, and
     // no messages sent.
     SerializedVarTestConstructor input1(host_object);
     SerializedVarReceiveInput receive_input(input1);
     plugin_object = receive_input.Get(plugin_dispatcher());
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
@@ skipping 20 matching lines @@
   }
 
   // Since we didn't keep any refs to the objects, it should have freed the
   // object.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
 }
 
 // Tests the case that the plugin receives the same vars twice as an input
 // parameter (not passing ownership) within a vector.
 TEST_F(SerializedVarTest, PluginVectorReceiveInput) {
+  ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);
 
   PP_Var* plugin_objects;
   PP_Var* plugin_objects2;
   {
     // Receive the params. The object should be tracked with no refcount and
     // no messages sent. The string should is plugin-side only and should have
     // a reference-count of 1.
     std::vector<SerializedVar> input1;
     input1.push_back(SerializedVarTestConstructor(host_object));
@@ skipping 46 matching lines @@
   // Since we didn't keep any refs to the objects or strings, so they should
   // have been freed.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects[0]));
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects[1]));
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects2[1]));
 }
 
 // Tests the plugin receiving a var as a return value from the browser
 // two different times (passing ownership).
 TEST_F(SerializedVarTest, PluginReceiveReturn) {
+  ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);
 
   PP_Var plugin_object;
   {
     // Receive the first param, we should be tracking it with a refcount of 1.
     SerializedVarTestConstructor input1(host_object);
     ReceiveSerializedVarReturnValue receive_input(input1);
     plugin_object = receive_input.Return(plugin_dispatcher());
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());
@@ skipping 23 matching lines @@
   // Manually release the last refcount, it should have freed it and sent a
   // release message to the browser.
   var_tracker().ReleaseVar(plugin_object);
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(2u, sink().message_count());
 }
 
 // Returns a value from the browser to the plugin, then return that one ref
 // back to the browser.
 TEST_F(SerializedVarTest, PluginReturnValue) {
+  ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);
 
   PP_Var plugin_object;
   {
     // Receive the param in the plugin.
     SerializedVarTestConstructor input1(host_object);
     ReceiveSerializedVarReturnValue receive_input(input1);
     plugin_object = receive_input.Return(plugin_dispatcher());
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());
@@ skipping 12 matching lines @@
   }
 
   // When the ReturnValue object goes out of scope, it should have sent a
   // release message to the browser.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(1u, sink().message_count());
 }
 
 }  // namespace proxy
 }  // namespace ppapi