ppapi/shared_impl/thread_aware_callback_unittest.cc

   1 // Copyright (c) 2012 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 "ppapi/shared_impl/thread_aware_callback.h"
   6
   7 #include "base/bind_helpers.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "ppapi/c/pp_errors.h"
  12 #include "ppapi/proxy/ppapi_proxy_test.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace ppapi {
  16
  17 namespace {
  18
  19 class TestParameter {
  20  public:
  21   TestParameter() : value_(0) {}
  22
  23   int value_;
  24 };
  25
  26 int called_num = 0;
  27
  28 void TestCallback_0() { ++called_num; }
  29
  30 void TestCallback_1(int p1) { ++called_num; }
  31
  32 void TestCallback_2(int p1, const double* p2) { ++called_num; }
  33
  34 void TestCallback_3(int p1, const double* p2, bool* p3) { ++called_num; }
  35
  36 void TestCallback_4(int p1, const double* p2, bool* p3, TestParameter p4) {
  37   ++called_num;
  38 }
  39
  40 void TestCallback_5(int p1,
  41                     const double* p2,
  42                     bool* p3,
  43                     TestParameter p4,
  44                     const TestParameter& p5) {
  45   ++called_num;
  46 }
  47
  48 typedef proxy::PluginProxyTest ThreadAwareCallbackTest;
  49
  50 // Test that a callback created on the main thread will run on the main thread,
  51 // even when requested from a different thread.
  52 class ThreadAwareCallbackMultiThreadTest
  53     : public proxy::PluginProxyMultiThreadTest {
  54  public:
  55   ThreadAwareCallbackMultiThreadTest() : main_thread_callback_called_(false) {}
  56   virtual ~ThreadAwareCallbackMultiThreadTest() {
  57     CHECK(main_thread_callback_called_);
  58   }
  59
  60   // proxy::PluginProxyMultiThreadTest implementation.
  61   virtual void SetUpTestOnMainThread() override {
  62     ProxyAutoLock auto_lock;
  63
  64     main_thread_callback_.reset(
  65         ThreadAwareCallback<CallbackFunc>::Create(&MainThreadCallbackBody));
  66   }
  67
  68   virtual void SetUpTestOnSecondaryThread() override {
  69     {
  70       ProxyAutoLock auto_lock;
  71       main_thread_callback_->RunOnTargetThread(this);
  72     }
  73
  74     PostQuitForSecondaryThread();
  75     PostQuitForMainThread();
  76   }
  77
  78  private:
  79   typedef void (*CallbackFunc)(ThreadAwareCallbackMultiThreadTest*);
  80
  81   static void MainThreadCallbackBody(ThreadAwareCallbackMultiThreadTest* thiz) {
  82     thiz->CheckOnThread(MAIN_THREAD);
  83     thiz->main_thread_callback_called_ = true;
  84
  85     {
  86       ProxyAutoLock auto_lock;
  87       // We have to destroy it prior to the PluginGlobals instance held by the
  88       // base class. Otherwise it has a ref to Pepper message loop for the main
  89       // thread and the PluginGlobals destructor will complain.
  90       thiz->main_thread_callback_.reset(NULL);
  91     }
  92   }
  93
  94   scoped_ptr<ThreadAwareCallback<CallbackFunc> > main_thread_callback_;
  95   bool main_thread_callback_called_;
  96 };
  97
  98 // Test that when a ThreadAwareCallback instance is destroyed, pending tasks to
  99 // run the callback will be ignored.
 100 class ThreadAwareCallbackAbortTest : public proxy::PluginProxyMultiThreadTest {
 101  public:
 102   ThreadAwareCallbackAbortTest() {}
 103   virtual ~ThreadAwareCallbackAbortTest() {}
 104
 105   // proxy::PluginProxyMultiThreadTest implementation.
 106   virtual void SetUpTestOnMainThread() override {
 107     ProxyAutoLock auto_lock;
 108
 109     main_thread_callback_.reset(
 110         ThreadAwareCallback<CallbackFunc>::Create(&MainThreadCallbackBody));
 111   }
 112
 113   virtual void SetUpTestOnSecondaryThread() override {
 114     {
 115       ProxyAutoLock auto_lock;
 116       main_thread_message_loop_proxy_->PostTask(
 117           FROM_HERE,
 118           base::Bind(&ThreadAwareCallbackAbortTest::DeleteCallback,
 119                      base::Unretained(this)));
 120       // |main_thread_callback_| is still valid, even if DeleteCallback() can be
 121       // called before this following statement. That is because |auto_lock| is
 122       // still held by this method, which prevents DeleteCallback() from
 123       // deleting the callback.
 124       main_thread_callback_->RunOnTargetThread(this);
 125     }
 126
 127     PostQuitForSecondaryThread();
 128     PostQuitForMainThread();
 129   }
 130
 131  private:
 132   typedef void (*CallbackFunc)(ThreadAwareCallbackAbortTest*);
 133
 134   static void MainThreadCallbackBody(ThreadAwareCallbackAbortTest* thiz) {
 135     // The callback should not be called.
 136     ASSERT_TRUE(false);
 137   }
 138
 139   void DeleteCallback() {
 140     ProxyAutoLock auto_lock;
 141     main_thread_callback_.reset(NULL);
 142   }
 143
 144   scoped_ptr<ThreadAwareCallback<CallbackFunc> > main_thread_callback_;
 145 };
 146
 147 }  // namespace
 148
 149 TEST_F(ThreadAwareCallbackTest, Basics) {
 150   // ThreadAwareCallback should only be used when the proxy lock has been
 151   // acquired.
 152   ProxyAutoLock auto_lock;
 153
 154   double double_arg = 0.0;
 155   bool bool_arg = false;
 156   TestParameter object_arg;
 157
 158   // Exercise all the template code.
 159   called_num = 0;
 160   typedef void (*FuncType_0)();
 161   scoped_ptr<ThreadAwareCallback<FuncType_0> > callback_0(
 162       ThreadAwareCallback<FuncType_0>::Create(TestCallback_0));
 163   callback_0->RunOnTargetThread();
 164
 165   typedef void (*FuncType_1)(int);
 166   scoped_ptr<ThreadAwareCallback<FuncType_1> > callback_1(
 167       ThreadAwareCallback<FuncType_1>::Create(TestCallback_1));
 168   callback_1->RunOnTargetThread(1);
 169
 170   typedef void (*FuncType_2)(int, const double*);
 171   scoped_ptr<ThreadAwareCallback<FuncType_2> > callback_2(
 172       ThreadAwareCallback<FuncType_2>::Create(TestCallback_2));
 173   callback_2->RunOnTargetThread(1, &double_arg);
 174
 175   typedef void (*FuncType_3)(int, const double*, bool*);
 176   scoped_ptr<ThreadAwareCallback<FuncType_3> > callback_3(
 177       ThreadAwareCallback<FuncType_3>::Create(TestCallback_3));
 178   callback_3->RunOnTargetThread(1, &double_arg, &bool_arg);
 179
 180   typedef void (*FuncType_4)(int, const double*, bool*, TestParameter);
 181   scoped_ptr<ThreadAwareCallback<FuncType_4> > callback_4(
 182       ThreadAwareCallback<FuncType_4>::Create(TestCallback_4));
 183   callback_4->RunOnTargetThread(1, &double_arg, &bool_arg, object_arg);
 184
 185   typedef void (*FuncType_5)(
 186       int, const double*, bool*, TestParameter, const TestParameter&);
 187   scoped_ptr<ThreadAwareCallback<FuncType_5> > callback_5(
 188       ThreadAwareCallback<FuncType_5>::Create(TestCallback_5));
 189   callback_5->RunOnTargetThread(
 190       1, &double_arg, &bool_arg, object_arg, object_arg);
 191
 192   EXPECT_EQ(6, called_num);
 193 }
 194
 195 TEST_F(ThreadAwareCallbackMultiThreadTest, RunOnTargetThread) { RunTest(); }
 196
 197 TEST_F(ThreadAwareCallbackAbortTest, NotRunIfAborted) { RunTest(); }
 198
 199 }  // namespace ppapi