| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 923263003:
PPAPI: Make TrackedCallback more threadsafe (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master