Porting ppapi_tests framework to postMessage.

ppapi/tests/test_case.h

 // Copyright (c) 2011 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 <string>
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/cpp/dev/scrollbar_dev.h"
+
+#if (defined __native_client__)
 #include "ppapi/cpp/var.h"
+#else
+#include "ppapi/cpp/private/var_private.h"
+#endif
 
 struct PPB_Testing_Dev;
 class TestingInstance;
 
 namespace pp {
 namespace deprecated {
 class ScriptableObject;
 }
 }
 
 // Individual classes of tests derive from this generic test case.
 class TestCase {
  public:
   explicit TestCase(TestingInstance* instance);
   virtual ~TestCase();
 
   // Optionally override to do testcase specific initialization.
   virtual bool Init() { return true; }
 
   // Override to implement the test. It will be called after the plugin is
   // first displayed.
   virtual void RunTest() = 0;
 
   static std::string MakeFailureMessage(const char* file, int line,
                                         const char* cmd);
 
+#if !(defined __native_client__)
   // Returns the scriptable test object for the current test, if any.
   // Internally, this uses CreateTestObject which each test overrides.
-  pp::Var GetTestObject();
+  pp::VarPrivate GetTestObject();
+#endif
 
   // A function that is invoked whenever HandleMessage is called on the
   // associated TestingInstance. Default implementation does nothing.  TestCases
   // that want to handle incoming postMessage events should override this
   // method.
   virtual void HandleMessage(const pp::Var& message_data);
 
  protected:
+#if !(defined __native_client__)
   // Overridden by each test to supply a ScriptableObject corresponding to the
   // test. There can only be one object created for all test in a given class
   // so be sure your object is designed to be re-used.
   //
   // This object should be created on the heap. Ownership will be passed to the
   // caller. Return NULL if there is no supported test object (the default).
   virtual pp::deprecated::ScriptableObject* CreateTestObject();
+#endif
 
   // Initializes the testing interface.
   bool InitTestingInterface();
 
   // Makes sure the test is run over HTTP.
   bool EnsureRunningOverHTTP();
 
   // Pointer to the instance that owns us.
   TestingInstance* instance_;
 
   // NULL unless InitTestingInterface is called.
   const PPB_Testing_Dev* testing_interface_;
 
   // Force asynchronous completion of any operation taking a callback.
   bool force_async_;
 
  private:
+#if !(defined __native_client__)
   // Holds the test object, if any was retrieved from CreateTestObject.
-  pp::Var test_object_;
+  pp::VarPrivate test_object_;
+#endif
 };
 
 // This class is an implementation detail.
 class TestCaseFactory {
  public:
   typedef TestCase* (*Method)(TestingInstance* instance);
 
   TestCaseFactory(const char* name, Method method)
       : next_(head_),
         name_(name),
@@ skipping 54 matching lines @@
 #define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd))
 #define ASSERT_EQ(a, b) ASSERT_TRUE((a) == (b))
 #define ASSERT_NE(a, b) ASSERT_TRUE((a) != (b))
 
 #define ASSERT_DOUBLE_EQ(a, b) ASSERT_TRUE( \
     std::fabs((a)-(b)) <= std::numeric_limits<double>::epsilon())
 
 #define PASS() return std::string()
 
 #endif  // PPAPI_TESTS_TEST_CASE_H_