ppapi/shared_impl/tracked_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 "base/bind.h"
   6 #include "base/memory/ref_counted.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "ppapi/c/pp_completion_callback.h"
   9 #include "ppapi/c/pp_errors.h"
  10 #include "ppapi/shared_impl/callback_tracker.h"
  11 #include "ppapi/shared_impl/proxy_lock.h"
  12 #include "ppapi/shared_impl/resource.h"
  13 #include "ppapi/shared_impl/resource_tracker.h"
  14 #include "ppapi/shared_impl/test_globals.h"
  15 #include "ppapi/shared_impl/tracked_callback.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace ppapi {
  19
  20 namespace {
  21
  22 class TrackedCallbackTest : public testing::Test {
  23  public:
  24   TrackedCallbackTest() : pp_instance_(1234) {}
  25
  26   PP_Instance pp_instance() const { return pp_instance_; }
  27
  28   virtual void SetUp() override {
  29     ProxyAutoLock lock;
  30     globals_.GetResourceTracker()->DidCreateInstance(pp_instance_);
  31   }
  32   virtual void TearDown() override {
  33     ProxyAutoLock lock;
  34     globals_.GetResourceTracker()->DidDeleteInstance(pp_instance_);
  35   }
  36
  37  private:
  38   base::MessageLoop message_loop_;
  39   TestGlobals globals_;
  40   PP_Instance pp_instance_;
  41 };
  42
  43 // All valid results (PP_OK, PP_ERROR_...) are nonpositive.
  44 const int32_t kInitializedResultValue = 1;
  45 const int32_t kOverrideResultValue = 2;
  46
  47 struct CallbackRunInfo {
  48   CallbackRunInfo()
  49       : run_count(0),
  50         result(kInitializedResultValue),
  51         completion_task_run_count(0),
  52         completion_task_result(kInitializedResultValue) {}
  53   unsigned run_count;
  54   int32_t result;
  55   unsigned completion_task_run_count;
  56   int32_t completion_task_result;
  57 };
  58
  59 void TestCallback(void* user_data, int32_t result) {
  60   CallbackRunInfo* info = reinterpret_cast<CallbackRunInfo*>(user_data);
  61   info->run_count++;
  62   if (info->run_count == 1)
  63     info->result = result;
  64 }
  65
  66 }  // namespace
  67
  68 // CallbackShutdownTest --------------------------------------------------------
  69
  70 namespace {
  71
  72 class CallbackShutdownTest : public TrackedCallbackTest {
  73  public:
  74   CallbackShutdownTest() {}
  75
  76   // Cases:
  77   // (1) A callback which is run (so shouldn't be aborted on shutdown).
  78   // (2) A callback which is aborted (so shouldn't be aborted on shutdown).
  79   // (3) A callback which isn't run (so should be aborted on shutdown).
  80   CallbackRunInfo& info_did_run() { return info_did_run_; }      // (1)
  81   CallbackRunInfo& info_did_abort() { return info_did_abort_; }  // (2)
  82   CallbackRunInfo& info_didnt_run() { return info_didnt_run_; }  // (3)
  83
  84  private:
  85   CallbackRunInfo info_did_run_;
  86   CallbackRunInfo info_did_abort_;
  87   CallbackRunInfo info_didnt_run_;
  88 };
  89
  90 }  // namespace
  91
  92 // Tests that callbacks are properly aborted on module shutdown.
  93 TEST_F(CallbackShutdownTest, AbortOnShutdown) {
  94   ProxyAutoLock lock;
  95   scoped_refptr<Resource> resource(new Resource(OBJECT_IS_IMPL, pp_instance()));
  96
  97   // Set up case (1) (see above).
  98   EXPECT_EQ(0U, info_did_run().run_count);
  99   scoped_refptr<TrackedCallback> callback_did_run = new TrackedCallback(
 100       resource.get(),
 101       PP_MakeCompletionCallback(&TestCallback, &info_did_run()));
 102   EXPECT_EQ(0U, info_did_run().run_count);
 103   callback_did_run->Run(PP_OK);
 104   EXPECT_EQ(1U, info_did_run().run_count);
 105   EXPECT_EQ(PP_OK, info_did_run().result);
 106
 107   // Set up case (2).
 108   EXPECT_EQ(0U, info_did_abort().run_count);
 109   scoped_refptr<TrackedCallback> callback_did_abort = new TrackedCallback(
 110       resource.get(),
 111       PP_MakeCompletionCallback(&TestCallback, &info_did_abort()));
 112   EXPECT_EQ(0U, info_did_abort().run_count);
 113   callback_did_abort->Abort();
 114   EXPECT_EQ(1U, info_did_abort().run_count);
 115   EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort().result);
 116
 117   // Set up case (3).
 118   EXPECT_EQ(0U, info_didnt_run().run_count);
 119   scoped_refptr<TrackedCallback> callback_didnt_run = new TrackedCallback(
 120       resource.get(),
 121       PP_MakeCompletionCallback(&TestCallback, &info_didnt_run()));
 122   EXPECT_EQ(0U, info_didnt_run().run_count);
 123
 124   PpapiGlobals::Get()->GetCallbackTrackerForInstance(pp_instance())->AbortAll();
 125
 126   // Check case (1).
 127   EXPECT_EQ(1U, info_did_run().run_count);
 128
 129   // Check case (2).
 130   EXPECT_EQ(1U, info_did_abort().run_count);
 131
 132   // Check case (3).
 133   EXPECT_EQ(1U, info_didnt_run().run_count);
 134   EXPECT_EQ(PP_ERROR_ABORTED, info_didnt_run().result);
 135 }
 136
 137 // CallbackResourceTest --------------------------------------------------------
 138
 139 namespace {
 140
 141 class CallbackResourceTest : public TrackedCallbackTest {
 142  public:
 143   CallbackResourceTest() {}
 144 };
 145
 146 class CallbackMockResource : public Resource {
 147  public:
 148   CallbackMockResource(PP_Instance instance)
 149       : Resource(OBJECT_IS_IMPL, instance) {}
 150   ~CallbackMockResource() {}
 151
 152   PP_Resource SetupForTest() {
 153     PP_Resource resource_id = GetReference();
 154     EXPECT_NE(0, resource_id);
 155
 156     callback_did_run_ = new TrackedCallback(
 157         this, PP_MakeCompletionCallback(&TestCallback, &info_did_run_));
 158     EXPECT_EQ(0U, info_did_run_.run_count);
 159     EXPECT_EQ(0U, info_did_run_.completion_task_run_count);
 160
 161     // In order to test that the completion task can override the callback
 162     // result, we need to test callbacks with and without a completion task.
 163     callback_did_run_with_completion_task_ = new TrackedCallback(
 164         this,
 165         PP_MakeCompletionCallback(&TestCallback,
 166                                   &info_did_run_with_completion_task_));
 167     callback_did_run_with_completion_task_->set_completion_task(
 168         Bind(&CallbackMockResource::CompletionTask,
 169              this,
 170              &info_did_run_with_completion_task_));
 171     EXPECT_EQ(0U, info_did_run_with_completion_task_.run_count);
 172     EXPECT_EQ(0U, info_did_run_with_completion_task_.completion_task_run_count);
 173
 174     callback_did_abort_ = new TrackedCallback(
 175         this, PP_MakeCompletionCallback(&TestCallback, &info_did_abort_));
 176     callback_did_abort_->set_completion_task(
 177         Bind(&CallbackMockResource::CompletionTask, this, &info_did_abort_));
 178     EXPECT_EQ(0U, info_did_abort_.run_count);
 179     EXPECT_EQ(0U, info_did_abort_.completion_task_run_count);
 180
 181     callback_didnt_run_ = new TrackedCallback(
 182         this, PP_MakeCompletionCallback(&TestCallback, &info_didnt_run_));
 183     callback_didnt_run_->set_completion_task(
 184         Bind(&CallbackMockResource::CompletionTask, this, &info_didnt_run_));
 185     EXPECT_EQ(0U, info_didnt_run_.run_count);
 186     EXPECT_EQ(0U, info_didnt_run_.completion_task_run_count);
 187
 188     callback_did_run_->Run(PP_OK);
 189     callback_did_run_with_completion_task_->Run(PP_OK);
 190     callback_did_abort_->Abort();
 191
 192     CheckIntermediateState();
 193
 194     return resource_id;
 195   }
 196
 197   int32_t CompletionTask(CallbackRunInfo* info, int32_t result) {
 198     // We should run before the callback.
 199     EXPECT_EQ(0U, info->run_count);
 200     info->completion_task_run_count++;
 201     if (info->completion_task_run_count == 1)
 202       info->completion_task_result = result;
 203     return kOverrideResultValue;
 204   }
 205
 206   void CheckIntermediateState() {
 207     EXPECT_EQ(1U, info_did_run_.run_count);
 208     EXPECT_EQ(PP_OK, info_did_run_.result);
 209     EXPECT_EQ(0U, info_did_run_.completion_task_run_count);
 210
 211     EXPECT_EQ(1U, info_did_run_with_completion_task_.run_count);
 212     // completion task should override the result.
 213     EXPECT_EQ(kOverrideResultValue, info_did_run_with_completion_task_.result);
 214     EXPECT_EQ(1U, info_did_run_with_completion_task_.completion_task_run_count);
 215     EXPECT_EQ(PP_OK, info_did_run_with_completion_task_.completion_task_result);
 216
 217     EXPECT_EQ(1U, info_did_abort_.run_count);
 218     // completion task shouldn't override an abort.
 219     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.result);
 220     EXPECT_EQ(1U, info_did_abort_.completion_task_run_count);
 221     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.completion_task_result);
 222
 223     EXPECT_EQ(0U, info_didnt_run_.completion_task_run_count);
 224     EXPECT_EQ(0U, info_didnt_run_.run_count);
 225   }
 226
 227   void CheckFinalState() {
 228     EXPECT_EQ(1U, info_did_run_.run_count);
 229     EXPECT_EQ(PP_OK, info_did_run_.result);
 230     EXPECT_EQ(1U, info_did_abort_.run_count);
 231     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.result);
 232     EXPECT_EQ(1U, info_didnt_run_.run_count);
 233     EXPECT_EQ(PP_ERROR_ABORTED, info_didnt_run_.result);
 234   }
 235
 236   scoped_refptr<TrackedCallback> callback_did_run_;
 237   CallbackRunInfo info_did_run_;
 238
 239   scoped_refptr<TrackedCallback> callback_did_run_with_completion_task_;
 240   CallbackRunInfo info_did_run_with_completion_task_;
 241
 242   scoped_refptr<TrackedCallback> callback_did_abort_;
 243   CallbackRunInfo info_did_abort_;
 244
 245   scoped_refptr<TrackedCallback> callback_didnt_run_;
 246   CallbackRunInfo info_didnt_run_;
 247 };
 248
 249 }  // namespace
 250
 251 // Test that callbacks get aborted on the last resource unref.
 252 TEST_F(CallbackResourceTest, AbortOnNoRef) {
 253   ProxyAutoLock lock;
 254   ResourceTracker* resource_tracker = PpapiGlobals::Get()->GetResourceTracker();
 255
 256   // Test several things: Unref-ing a resource (to zero refs) with callbacks
 257   // which (1) have been run, (2) have been aborted, (3) haven't been completed.
 258   // Check that the uncompleted one gets aborted, and that the others don't get
 259   // called again.
 260   scoped_refptr<CallbackMockResource> resource_1(
 261       new CallbackMockResource(pp_instance()));
 262   PP_Resource resource_1_id = resource_1->SetupForTest();
 263
 264   // Also do the same for a second resource, and make sure that unref-ing the
 265   // first resource doesn't much up the second resource.
 266   scoped_refptr<CallbackMockResource> resource_2(
 267       new CallbackMockResource(pp_instance()));
 268   PP_Resource resource_2_id = resource_2->SetupForTest();
 269
 270   // Double-check that resource #1 is still okay.
 271   resource_1->CheckIntermediateState();
 272
 273   // Kill resource #1, spin the message loop to run posted calls, and check that
 274   // things are in the expected states.
 275   resource_tracker->ReleaseResource(resource_1_id);
 276   {
 277     ProxyAutoUnlock unlock;
 278     base::MessageLoop::current()->RunUntilIdle();
 279   }
 280   resource_1->CheckFinalState();
 281   resource_2->CheckIntermediateState();
 282
 283   // Kill resource #2.
 284   resource_tracker->ReleaseResource(resource_2_id);
 285   {
 286     ProxyAutoUnlock unlock;
 287     base::MessageLoop::current()->RunUntilIdle();
 288   }
 289   resource_1->CheckFinalState();
 290   resource_2->CheckFinalState();
 291
 292   // This shouldn't be needed, but make sure there are no stranded tasks.
 293   {
 294     ProxyAutoUnlock unlock;
 295     base::MessageLoop::current()->RunUntilIdle();
 296   }
 297 }
 298
 299 // Test that "resurrecting" a resource (getting a new ID for a |Resource|)
 300 // doesn't resurrect callbacks.
 301 TEST_F(CallbackResourceTest, Resurrection) {
 302   ProxyAutoLock lock;
 303   ResourceTracker* resource_tracker = PpapiGlobals::Get()->GetResourceTracker();
 304
 305   scoped_refptr<CallbackMockResource> resource(
 306       new CallbackMockResource(pp_instance()));
 307   PP_Resource resource_id = resource->SetupForTest();
 308
 309   // Unref it, spin the message loop to run posted calls, and check that things
 310   // are in the expected states.
 311   resource_tracker->ReleaseResource(resource_id);
 312   {
 313     ProxyAutoUnlock unlock;
 314     base::MessageLoop::current()->RunUntilIdle();
 315   }
 316   resource->CheckFinalState();
 317
 318   // "Resurrect" it and check that the callbacks are still dead.
 319   PP_Resource new_resource_id = resource->GetReference();
 320   {
 321     ProxyAutoUnlock unlock;
 322     base::MessageLoop::current()->RunUntilIdle();
 323   }
 324   resource->CheckFinalState();
 325
 326   // Unref it again and do the same.
 327   resource_tracker->ReleaseResource(new_resource_id);
 328   {
 329     ProxyAutoUnlock unlock;
 330     base::MessageLoop::current()->RunUntilIdle();
 331   }
 332   resource->CheckFinalState();
 333
 334   // This shouldn't be needed, but make sure there are no stranded tasks.
 335   {
 336     ProxyAutoUnlock unlock;
 337     base::MessageLoop::current()->RunUntilIdle();
 338   }
 339 }
 340
 341 }  // namespace ppapi