Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1532)

Unified Diff: ppapi/shared_impl/proxy_lock_unittest.cc

Issue 19492014: PPAPI: Purposely leak ProxyLock, fix shutdown race (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Review comments Created 7 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: ppapi/shared_impl/proxy_lock_unittest.cc
diff --git a/ppapi/shared_impl/proxy_lock_unittest.cc b/ppapi/shared_impl/proxy_lock_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..caa0672cddf7e6b622b8fcd25f8b01fcb196206e
--- /dev/null
+++ b/ppapi/shared_impl/proxy_lock_unittest.cc
@@ -0,0 +1,163 @@
+// Copyright (c) 2013 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 <string>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "ppapi/shared_impl/proxy_lock.h"
+#include "ppapi/shared_impl/test_globals.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace ppapi {
+
+namespace {
+
+bool expect_to_be_locked = false;
+void CheckLockState() {
+ if (expect_to_be_locked) {
+ ProxyLock::AssertAcquired();
+ } else {
+ // If we expect to be unlocked, try to lock. We rely on the checking inside
+ // base::Lock that prevents recursive locking.
+ ProxyAutoLock lock;
+ }
+}
+
+int called_num = 0;
+
+class CheckLockStateInDestructor
+ : public base::RefCounted<CheckLockStateInDestructor> {
+ public:
+ CheckLockStateInDestructor() {}
+ void Method() {
+ ++called_num;
+ }
+ private:
+ friend class base::RefCounted<CheckLockStateInDestructor>;
+ ~CheckLockStateInDestructor() {
+ CheckLockState();
+ }
+ DISALLOW_COPY_AND_ASSIGN(CheckLockStateInDestructor);
+};
+
+void TestCallback_0() {
+ CheckLockState();
+ ++called_num;
+}
+
+void TestCallback_1(int p1) {
+ CheckLockState();
+ ++called_num;
+}
+
+void TestCallback_2(int p1, const std::string& p2) {
+ CheckLockState();
+ ++called_num;
+}
+
+struct Param {};
+void TestCallback_3(int p1, const std::string& p2, Param p3) {
+ CheckLockState();
+ ++called_num;
+}
+
+} // namespace
+
+TEST(PpapiProxyLockTest, Locking) {
+ TestGlobals globals;
+ base::Lock lock;
+ globals.set_proxy_lock(&lock);
+ expect_to_be_locked = true;
+
+ {
+ base::Callback<void()> cb(RunWhileLocked(base::Bind(TestCallback_0)));
+ cb.Run();
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void()> cb(RunWhileLocked(base::Bind(TestCallback_1, 123)));
+ cb.Run();
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ scoped_refptr<CheckLockStateInDestructor> object =
+ new CheckLockStateInDestructor();
+ base::Callback<void()> cb(
+ RunWhileLocked(
+ base::Bind(&CheckLockStateInDestructor::Method,
+ object)));
+ // Clear the scoped_refptr so that the Callback owns the only reference.
+ object = NULL;
+ cb.Run();
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void(int)> cb(RunWhileLocked(base::Bind(TestCallback_1)));
+ cb.Run(123);
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void(int, const std::string&)> cb(
+ RunWhileLocked(base::Bind(TestCallback_2)));
+ cb.Run(123, std::string("yo"));
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void(int, const std::string&, Param)> cb(
+ RunWhileLocked(base::Bind(TestCallback_3)));
+ cb.Run(123, std::string("yo"), Param());
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void(const std::string&)> cb(
+ RunWhileLocked(base::Bind(TestCallback_2, 123)));
+ cb.Run(std::string("yo"));
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void()> cb(
+ RunWhileLocked(base::Bind(TestCallback_2, 123, std::string("yo"))));
+ cb.Run();
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ }
+}
+
+TEST(PpapiProxyLockTest, Unlocking) {
+ TestGlobals globals;
+ base::Lock lock;
+ globals.set_proxy_lock(&lock);
+ expect_to_be_locked = false;
+ // These calls should all try to _unlock_, so we must be locked before
+ // entering them.
+ ProxyAutoLock auto_lock;
+
+ {
+ CallWhileUnlocked(TestCallback_0);
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ CallWhileUnlocked(TestCallback_1, 123);
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ // TODO(dmichael): Make const-ref arguments work properly with type
+ // deduction.
+ CallWhileUnlocked<void, int, const std::string&>(
+ TestCallback_2, 123, std::string("yo"));
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ } {
+ base::Callback<void()> callback(base::Bind(TestCallback_0));
+ CallWhileUnlocked(callback);
+ ASSERT_EQ(1, called_num);
+ called_num = 0;
+ }
+}
+
+} // namespace ppapi

Powered by Google App Engine
This is Rietveld 408576698