PPAPI: Refactor ppapi test callbacks to ease testing blocking callbacks.

ppapi/tests/test_case.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PPAPI_TESTS_TEST_CASE_H_
 #define PPAPI_TESTS_TEST_CASE_H_
 
 #include <cmath>
 #include <limits>
 #include <set>
 #include <string>
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/cpp/dev/scrollbar_dev.h"
 #include "ppapi/cpp/view.h"
+#include "ppapi/tests/test_utils.h"
 
 #if (defined __native_client__)
 #include "ppapi/cpp/var.h"
 #else
 #include "ppapi/cpp/private/var_private.h"
 #endif
 
 class TestingInstance;
 
 namespace pp {
@@ skipping 74 matching lines @@
   bool MatchesFilter(const std::string& test_name, const std::string& filter);
 
   // Check for leaked resources and vars at the end of the test. If any exist,
   // return a string with some information about the error. Otherwise, return
   // an empty string.
   std::string CheckResourcesAndVars();
 
   // Pointer to the instance that owns us.
   TestingInstance* instance_;
 
+ protected:
   // NULL unless InitTestingInterface is called.
   const PPB_Testing_Dev* testing_interface_;
 
-  // Force asynchronous completion of any operation taking a callback.
+  // TODO(dmichael): Remove this, it's for temporary backwards compatibility so
+  // I don't have to change all the tests at once.
   bool force_async_;
 
+  void set_callback_type(CallbackType callback_type) {
+    callback_type_ = callback_type;
+    // TODO(dmichael): Remove this; see comment on force_async_.
+    force_async_ = (callback_type_ == PP_REQUIRED);
+  }
+  CallbackType callback_type() const {
+    return callback_type_;
+  }
+
  private:
+  // Passed when creating completion callbacks in some tests. This determines
+  // what kind of callback we use for the test.
+  CallbackType callback_type_;
+
   // Var ids that should be ignored when checking for leaks on shutdown.
   std::set<int64_t> ignored_leaked_vars_;
 
 #if !(defined __native_client__)
   // Holds the test object, if any was retrieved from CreateTestObject.
   pp::VarPrivate test_object_;
 #endif
 };
 
 // This class is an implementation detail.
@@ skipping 32 matching lines @@
   }                                                                         \
   static TestCaseFactory g_Test##name_factory(                              \
     #name, &Test##name##_FactoryMethod                                      \
   )
 
 // Helper macro for calling functions implementing specific tests in the
 // RunTest function. This assumes the function name is TestFoo where Foo is the
 // test |name|.
 #define RUN_TEST(name, test_filter) \
   if (MatchesFilter(#name, test_filter)) { \
-    force_async_ = false; \
+    set_callback_type(PP_OPTIONAL); \
     std::string error_message = Test##name(); \
     if (error_message.empty()) \
       error_message = CheckResourcesAndVars(); \
     instance_->LogTest(#name, error_message); \
   }
 
 #define RUN_TEST_WITH_REFERENCE_CHECK(name, test_filter) \
   if (MatchesFilter(#name, test_filter)) { \
-    force_async_ = false; \
+    set_callback_type(PP_OPTIONAL); \
     uint32_t objects = testing_interface_->GetLiveObjectsForInstance( \
         instance_->pp_instance()); \
     std::string error_message = Test##name(); \
     if (error_message.empty() && \
         testing_interface_->GetLiveObjectsForInstance( \
             instance_->pp_instance()) != objects) \
       error_message = MakeFailureMessage(__FILE__, __LINE__, \
           "reference leak check"); \
     instance_->LogTest(#name, error_message); \
   }
 
 // Like RUN_TEST above but forces functions taking callbacks to complete
 // asynchronously on success or error.
 #define RUN_TEST_FORCEASYNC(name, test_filter) \
   if (MatchesFilter(#name"ForceAsync", test_filter)) { \
-    force_async_ = true; \
+    set_callback_type(PP_REQUIRED); \
     instance_->LogTest(#name"ForceAsync", Test##name()); \
   }
 
 #define RUN_TEST_FORCEASYNC_AND_NOT(name, test_filter) \
   do { \
     RUN_TEST_FORCEASYNC(name, test_filter); \
     RUN_TEST(name, test_filter); \
   } while (false)
 
 
@@ skipping 14 matching lines @@
 #define ASSERT_SUBTEST_SUCCESS(function) \
   do { \
     std::string result = (function); \
     if (!result.empty()) \
       return result; \
   } while (false)
 
 #define PASS() return std::string()
 
 #endif  // PPAPI_TESTS_TEST_CASE_H_