ppapi/shared_impl/proxy_lock_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "ppapi/shared_impl/proxy_lock.h"
  14 #include "ppapi/shared_impl/test_globals.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace ppapi {
  18
  19 namespace {
  20
  21 bool expect_to_be_locked = false;
  22 void CheckLockState() {
  23   if (expect_to_be_locked) {
  24     ProxyLock::AssertAcquired();
  25   } else {
  26     // If we expect to be unlocked, try to lock. We rely on the checking inside
  27     // base::Lock that prevents recursive locking.
  28     ProxyAutoLock lock;
  29   }
  30 }
  31
  32 int called_num = 0;
  33
  34 class CheckLockStateInDestructor
  35     : public base::RefCounted<CheckLockStateInDestructor> {
  36  public:
  37   CheckLockStateInDestructor() {}
  38   void Method() { ++called_num; }
  39
  40  private:
  41   friend class base::RefCounted<CheckLockStateInDestructor>;
  42   ~CheckLockStateInDestructor() { CheckLockState(); }
  43   DISALLOW_COPY_AND_ASSIGN(CheckLockStateInDestructor);
  44 };
  45
  46 void TestCallback_0() {
  47   CheckLockState();
  48   ++called_num;
  49 }
  50
  51 void TestCallback_1(int p1) {
  52   CheckLockState();
  53   ++called_num;
  54 }
  55
  56 void TestCallback_2(int p1, const std::string& p2) {
  57   CheckLockState();
  58   ++called_num;
  59 }
  60
  61 struct Param {};
  62 void TestCallback_3(int p1, const std::string& p2, Param p3) {
  63   CheckLockState();
  64   ++called_num;
  65 }
  66
  67 }  // namespace
  68
  69 class PpapiProxyLockTest : public testing::Test {
  70   base::MessageLoop message_loop_;  // Required to receive callbacks.
  71 };
  72
  73 TEST_F(PpapiProxyLockTest, Locking) {
  74   TestGlobals globals;
  75   expect_to_be_locked = true;
  76
  77   base::Callback<void()> cb0;
  78   {
  79     ProxyAutoLock lock;
  80     cb0 = RunWhileLocked(base::Bind(TestCallback_0));
  81   }
  82   cb0.Run();
  83   ASSERT_EQ(1, called_num);
  84   called_num = 0;
  85
  86   {
  87     ProxyAutoLock lock;
  88     cb0 = RunWhileLocked(base::Bind(TestCallback_1, 123));
  89   }
  90   cb0.Run();
  91   ASSERT_EQ(1, called_num);
  92   called_num = 0;
  93
  94   {
  95     ProxyAutoLock lock;
  96     scoped_refptr<CheckLockStateInDestructor> object =
  97         new CheckLockStateInDestructor();
  98     cb0 =
  99         RunWhileLocked(base::Bind(&CheckLockStateInDestructor::Method, object));
 100     // Note after this scope, the Callback owns the only reference.
 101   }
 102   cb0.Run();
 103   ASSERT_EQ(1, called_num);
 104   called_num = 0;
 105
 106   base::Callback<void(int)> cb1;
 107   {
 108     ProxyAutoLock lock;
 109     cb1 = RunWhileLocked(base::Bind(TestCallback_1));
 110   }
 111   cb1.Run(123);
 112   ASSERT_EQ(1, called_num);
 113   called_num = 0;
 114
 115   base::Callback<void(int, const std::string&)> cb2;
 116   {
 117     ProxyAutoLock lock;
 118     cb2 = RunWhileLocked(base::Bind(TestCallback_2));
 119   }
 120   cb2.Run(123, std::string("yo"));
 121   ASSERT_EQ(1, called_num);
 122   called_num = 0;
 123
 124   base::Callback<void(int, const std::string&, Param)> cb3;
 125   {
 126     ProxyAutoLock lock;
 127     cb3 = RunWhileLocked(base::Bind(TestCallback_3));
 128   }
 129   cb3.Run(123, std::string("yo"), Param());
 130   ASSERT_EQ(1, called_num);
 131   called_num = 0;
 132
 133   base::Callback<void(const std::string&)> cb1_string;
 134   {
 135     ProxyAutoLock lock;
 136     cb1_string = RunWhileLocked(base::Bind(TestCallback_2, 123));
 137   }
 138   cb1_string.Run(std::string("yo"));
 139   ASSERT_EQ(1, called_num);
 140   called_num = 0;
 141
 142   {
 143     ProxyAutoLock lock;
 144     cb0 = RunWhileLocked(base::Bind(TestCallback_2, 123, std::string("yo")));
 145   }
 146   cb0.Run();
 147   ASSERT_EQ(1, called_num);
 148   called_num = 0;
 149 }
 150
 151 TEST_F(PpapiProxyLockTest, Unlocking) {
 152   TestGlobals globals;
 153   expect_to_be_locked = false;
 154   // These calls should all try to _unlock_, so we must be locked before
 155   // entering them.
 156   ProxyAutoLock auto_lock;
 157
 158   {
 159     CallWhileUnlocked(TestCallback_0);
 160     ASSERT_EQ(1, called_num);
 161     called_num = 0;
 162   }
 163   {
 164     CallWhileUnlocked(TestCallback_1, 123);
 165     ASSERT_EQ(1, called_num);
 166     called_num = 0;
 167   }
 168   {
 169     // TODO(dmichael): Make const-ref arguments work properly with type
 170     // deduction.
 171     CallWhileUnlocked<void, int, const std::string&>(
 172         TestCallback_2, 123, std::string("yo"));
 173     ASSERT_EQ(1, called_num);
 174     called_num = 0;
 175   }
 176   {
 177     base::Callback<void()> callback(base::Bind(TestCallback_0));
 178     CallWhileUnlocked(callback);
 179     ASSERT_EQ(1, called_num);
 180     called_num = 0;
 181   }
 182 }
 183
 184 }  // namespace ppapi