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