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