Move the tracked completion callback code into shared impl.

ppapi/shared_impl/tracked_callback_unittest.cc

Index: ppapi/shared_impl/tracked_callback_unittest.cc
===================================================================
--- ppapi/shared_impl/tracked_callback_unittest.cc	(revision 115831)
+++ ppapi/shared_impl/tracked_callback_unittest.cc	(working copy)
@@ -8,17 +8,38 @@
 #include "base/message_loop.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/shared_impl/callback_tracker.h"
+#include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/resource_tracker.h"
-#include "webkit/plugins/ppapi/callbacks.h"
-#include "webkit/plugins/ppapi/host_globals.h"
-#include "webkit/plugins/ppapi/mock_resource.h"
-#include "webkit/plugins/ppapi/plugin_module.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
-#include "webkit/plugins/ppapi/resource_helper.h"
+#include "ppapi/shared_impl/tracked_callback.h"
+#include "ppapi/shared_impl/test_globals.h"

[viettrungluu, 2011/12/29 03:45:27]

nit: alphabetical order

+#include "testing/gtest/include/gtest/gtest.h"
 
-namespace webkit {
 namespace ppapi {
 
+namespace {
+
+class TrackedCallbackTest : public testing::Test {
+ public:
+  TrackedCallbackTest()
+      : message_loop_(MessageLoop::TYPE_DEFAULT),
+        pp_instance_(1234) {}
+
+  PP_Instance pp_instance() const { return pp_instance_; }
+
+  virtual void SetUp() OVERRIDE {
+    globals_.GetResourceTracker()->DidCreateInstance(pp_instance_);
+  }
+  virtual void TearDown() OVERRIDE {
+    globals_.GetResourceTracker()->DidDeleteInstance(pp_instance_);
+  }
+
+ private:
+  MessageLoop message_loop_;
+  TestGlobals globals_;
+  PP_Instance pp_instance_;
+};
+
 struct CallbackRunInfo {
   // All valid results (PP_OK, PP_ERROR_...) are nonpositive.
   CallbackRunInfo() : run_count(0), result(1) {}
@@ -26,8 +47,6 @@
   int32_t result;
 };
 
-namespace {
-
 void TestCallback(void* user_data, int32_t result) {
   CallbackRunInfo* info = reinterpret_cast<CallbackRunInfo*>(user_data);
   info->run_count++;
@@ -39,8 +58,9 @@
 
 // CallbackShutdownTest --------------------------------------------------------
 
-// Tests that callbacks are properly aborted on module shutdown.
-class CallbackShutdownTest : public PpapiUnittest {
+namespace {
+
+class CallbackShutdownTest : public TrackedCallbackTest {
  public:
   CallbackShutdownTest() {}
 
@@ -58,14 +78,17 @@
   CallbackRunInfo info_didnt_run_;
 };
 
+}  // namespace
+
+// Tests that callbacks are properly aborted on module shutdown.
 TEST_F(CallbackShutdownTest, AbortOnShutdown) {
+  scoped_refptr<Resource> resource(new Resource(pp_instance()));
+
   // Set up case (1) (see above).
   EXPECT_EQ(0U, info_did_run().run_count);
-  scoped_refptr<TrackedCompletionCallback> callback_did_run =
-      new TrackedCompletionCallback(
-          instance()->module()->GetCallbackTracker(),
-          0,
-          PP_MakeCompletionCallback(&TestCallback, &info_did_run()));
+  scoped_refptr<TrackedCallback> callback_did_run = new TrackedCallback(
+      resource.get(),
+      PP_MakeCompletionCallback(&TestCallback, &info_did_run()));
   EXPECT_EQ(0U, info_did_run().run_count);
   callback_did_run->Run(PP_OK);
   EXPECT_EQ(1U, info_did_run().run_count);
@@ -73,27 +96,22 @@
 
   // Set up case (2).
   EXPECT_EQ(0U, info_did_abort().run_count);
-  scoped_refptr<TrackedCompletionCallback> callback_did_abort =
-      new TrackedCompletionCallback(
-          instance()->module()->GetCallbackTracker(),
-          0,
-          PP_MakeCompletionCallback(&TestCallback, &info_did_abort()));
+  scoped_refptr<TrackedCallback> callback_did_abort = new TrackedCallback(
+      resource.get(),
+      PP_MakeCompletionCallback(&TestCallback, &info_did_abort()));
   EXPECT_EQ(0U, info_did_abort().run_count);
   callback_did_abort->Abort();
   EXPECT_EQ(1U, info_did_abort().run_count);
   EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort().result);
 
-
   // Set up case (3).
   EXPECT_EQ(0U, info_didnt_run().run_count);
-  scoped_refptr<TrackedCompletionCallback> callback_didnt_run =
-      new TrackedCompletionCallback(
-          instance()->module()->GetCallbackTracker(),
-          0,
-          PP_MakeCompletionCallback(&TestCallback, &info_didnt_run()));
+  scoped_refptr<TrackedCallback> callback_didnt_run = new TrackedCallback(
+      resource.get(),
+      PP_MakeCompletionCallback(&TestCallback, &info_didnt_run()));
   EXPECT_EQ(0U, info_didnt_run().run_count);
 
-  ShutdownModule();
+  PpapiGlobals::Get()->GetCallbackTrackerForInstance(pp_instance())->AbortAll();
 
   // Check case (1).
   EXPECT_EQ(1U, info_did_run().run_count);
@@ -106,36 +124,36 @@
   EXPECT_EQ(PP_ERROR_ABORTED, info_didnt_run().result);
 }
 
-// -----------------------------------------------------------------------------
+// CallbackResourceTest --------------------------------------------------------
 
 namespace {
 
-class CallbackMockResource : public MockResource {
+class CallbackResourceTest : public TrackedCallbackTest {
  public:
-  CallbackMockResource(PP_Instance instance) : MockResource(instance) {}
+  CallbackResourceTest() {}
+};
+
+class CallbackMockResource : public Resource {
+ public:
+  CallbackMockResource(PP_Instance instance) : Resource(instance) {}
   ~CallbackMockResource() {}
 
   PP_Resource SetupForTest() {
     PP_Resource resource_id = GetReference();
     EXPECT_NE(0, resource_id);
 
-    PluginModule* module = ResourceHelper::GetPluginModule(this);
-
-    callback_did_run_ = new TrackedCompletionCallback(
-        module->GetCallbackTracker(),
-        resource_id,
+    callback_did_run_ = new TrackedCallback(
+        this,
         PP_MakeCompletionCallback(&TestCallback, &info_did_run_));
     EXPECT_EQ(0U, info_did_run_.run_count);
 
-    callback_did_abort_ = new TrackedCompletionCallback(
-        module->GetCallbackTracker(),
-        resource_id,
+    callback_did_abort_ = new TrackedCallback(
+        this,
         PP_MakeCompletionCallback(&TestCallback, &info_did_abort_));
     EXPECT_EQ(0U, info_did_abort_.run_count);
 
-    callback_didnt_run_ = new TrackedCompletionCallback(
-        module->GetCallbackTracker(),
-        resource_id,
+    callback_didnt_run_ = new TrackedCallback(
+        this,
         PP_MakeCompletionCallback(&TestCallback, &info_didnt_run_));
     EXPECT_EQ(0U, info_didnt_run_.run_count);
 
@@ -166,40 +184,35 @@
     EXPECT_EQ(PP_ERROR_ABORTED, info_didnt_run_.result);
   }
 
-  scoped_refptr<TrackedCompletionCallback> callback_did_run_;
+  scoped_refptr<TrackedCallback> callback_did_run_;
   CallbackRunInfo info_did_run_;
 
-  scoped_refptr<TrackedCompletionCallback> callback_did_abort_;
+  scoped_refptr<TrackedCallback> callback_did_abort_;
   CallbackRunInfo info_did_abort_;
 
-  scoped_refptr<TrackedCompletionCallback> callback_didnt_run_;
+  scoped_refptr<TrackedCallback> callback_didnt_run_;
   CallbackRunInfo info_didnt_run_;
 };
 
 }  // namespace
 
-class CallbackResourceTest : public PpapiUnittest {
- public:
-  CallbackResourceTest() {}
-};
-
 // Test that callbacks get aborted on the last resource unref.
 TEST_F(CallbackResourceTest, AbortOnNoRef) {
-  HostResourceTracker* resource_tracker =
-      HostGlobals::Get()->host_resource_tracker();
+  ResourceTracker* resource_tracker =
+      PpapiGlobals::Get()->GetResourceTracker();
 
   // Test several things: Unref-ing a resource (to zero refs) with callbacks
   // which (1) have been run, (2) have been aborted, (3) haven't been completed.
   // Check that the uncompleted one gets aborted, and that the others don't get
   // called again.
   scoped_refptr<CallbackMockResource> resource_1(
-      new CallbackMockResource(instance()->pp_instance()));
+      new CallbackMockResource(pp_instance()));
   PP_Resource resource_1_id = resource_1->SetupForTest();
 
   // Also do the same for a second resource, and make sure that unref-ing the
   // first resource doesn't much up the second resource.
   scoped_refptr<CallbackMockResource> resource_2(
-      new CallbackMockResource(instance()->pp_instance()));
+      new CallbackMockResource(pp_instance()));
   PP_Resource resource_2_id = resource_2->SetupForTest();
 
   // Double-check that resource #1 is still okay.
@@ -225,11 +238,11 @@
 // Test that "resurrecting" a resource (getting a new ID for a |Resource|)
 // doesn't resurrect callbacks.
 TEST_F(CallbackResourceTest, Resurrection) {
-  HostResourceTracker* resource_tracker =
-      HostGlobals::Get()->host_resource_tracker();
+  ResourceTracker* resource_tracker =
+      PpapiGlobals::Get()->GetResourceTracker();
 
   scoped_refptr<CallbackMockResource> resource(
-      new CallbackMockResource(instance()->pp_instance()));
+      new CallbackMockResource(pp_instance()));
   PP_Resource resource_id = resource->SetupForTest();
 
   // Unref it, spin the message loop to run posted calls, and check that things
@@ -253,4 +266,3 @@
 }
 
 }  // namespace ppapi
-}  // namespace webkit