Move PPB_VarArray and PPB_VarDictionary out of dev.

ppapi/tests/test_post_message.cc

 // 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.
 
 #include "ppapi/tests/test_post_message.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/var.h"
+#include "ppapi/cpp/var_array.h"
 #include "ppapi/cpp/var_array_buffer.h"
+#include "ppapi/cpp/var_dictionary.h"
 #include "ppapi/tests/pp_thread.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
 #ifdef PostMessage
 #undef PostMessage
 #endif
 
 REGISTER_TEST_CASE(PostMessage);
@@ skipping 49 matching lines @@
       if (it->second == actual.pp_var().value.as_id)
         return true;
       return false;
     }
     (*visited_ids)[expected.pp_var().value.as_id] = actual.pp_var().value.as_id;
   }
 
   if (expected.is_number()) {
     return fabs(expected.AsDouble() - actual.AsDouble()) < 1.0e-4;
   } else if (expected.is_array()) {
-    pp::VarArray_Dev expected_array(expected);
-    pp::VarArray_Dev actual_array(actual);
+    pp::VarArray expected_array(expected);
+    pp::VarArray actual_array(actual);
     if (expected_array.GetLength() != actual_array.GetLength())
       return false;
     for (uint32_t i = 0; i < expected_array.GetLength(); ++i) {
       if (!VarsEqual(expected_array.Get(i), actual_array.Get(i), visited_ids))
         return false;
     }
     return true;
   } else if (expected.is_dictionary()) {
-    pp::VarDictionary_Dev expected_dict(expected);
-    pp::VarDictionary_Dev actual_dict(actual);
+    pp::VarDictionary expected_dict(expected);
+    pp::VarDictionary actual_dict(actual);
     if (expected_dict.GetKeys().GetLength() !=
         actual_dict.GetKeys().GetLength()) {
       return false;
     }
     for (uint32_t i = 0; i < expected_dict.GetKeys().GetLength(); ++i) {
       pp::Var key = expected_dict.GetKeys().Get(i);
-      if (actual_dict.HasKey(key) == PP_FALSE)
+      if (!actual_dict.HasKey(key))
         return false;
       if (!VarsEqual(expected_dict.Get(key), actual_dict.Get(key), visited_ids))
         return false;
     }
     return true;
   } else {
     return expected == actual;
   }
 }
 
@@ skipping 327 matching lines @@
   PASS();
 }
 
 std::string TestPostMessage::TestSendingArray() {
   // Clean up after previous tests. This also swallows the message sent by Init
   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
   // should start with these.
   WaitForMessages();
   ASSERT_TRUE(ClearListeners());
 
-  pp::VarArray_Dev array;
+  pp::VarArray array;
   array.Set(0, pp::Var(kTestBool));
   array.Set(1, pp::Var(kTestString));
   // Purposely leave index 2 empty.
   array.Set(3, pp::Var(kTestInt));
   array.Set(4, pp::Var(kTestDouble));
 
   std::stringstream ss;
   ss << array.GetLength();
   std::string length_as_string(ss.str());
 
@@ skipping 22 matching lines @@
   PASS();
 }
 
 std::string TestPostMessage::TestSendingDictionary() {
   // Clean up after previous tests. This also swallows the message sent by Init
   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
   // should start with these.
   WaitForMessages();
   ASSERT_TRUE(ClearListeners());
 
-  pp::VarDictionary_Dev dictionary;
+  pp::VarDictionary dictionary;
   dictionary.Set(pp::Var("foo"), pp::Var(kTestBool));
   dictionary.Set(pp::Var("bar"), pp::Var(kTestString));
   dictionary.Set(pp::Var("abc"), pp::Var(kTestInt));
   dictionary.Set(pp::Var("def"), pp::Var());
 
   std::stringstream ss;
   ss << dictionary.GetKeys().GetLength();
   std::string length_as_string(ss.str());
 
   // Have the listener test some properties of the Dictionary.
@@ skipping 25 matching lines @@
 
 std::string TestPostMessage::TestSendingComplexVar() {
   // Clean up after previous tests. This also swallows the message sent by Init
   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
   // should start with these.
   WaitForMessages();
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   pp::Var string(kTestString);
-  pp::VarDictionary_Dev dictionary;
+  pp::VarDictionary dictionary;
   dictionary.Set(pp::Var("foo"), pp::Var(kTestBool));
   dictionary.Set(pp::Var("bar"), string);
   dictionary.Set(pp::Var("abc"), pp::Var(kTestInt));
   dictionary.Set(pp::Var("def"), pp::Var());
 
   // Reference to array.
-  pp::VarArray_Dev array;
+  pp::VarArray array;
   array.Set(0, pp::Var(kTestBool));
   array.Set(1, string);
   // Purposely leave index 2 empty (which will place an undefined var there).
   array.Set(3, pp::Var(kTestInt));
   array.Set(4, pp::Var(kTestDouble));
 
   dictionary.Set(pp::Var("array-ref1"), array);
   dictionary.Set(pp::Var("array-ref2"), array);
 
   // Set up the JavaScript message event listener to echo the data part of the
   // message event back to us.
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
   instance_->PostMessage(dictionary);
   // PostMessage is asynchronous, so we should not receive a response yet.
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_dictionary());
-  pp::VarDictionary_Dev result(message_data_.back());
+  pp::VarDictionary result(message_data_.back());
   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
 
   WaitForMessages();
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   // Set up a (dictionary -> array -> dictionary) cycle. Cycles shouldn't be
   // transmitted.
-  pp::VarArray_Dev array2;
+  pp::VarArray array2;
   array2.Set(0, dictionary);
   dictionary.Set(pp::Var("array2"), array2);
 
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
   instance_->PostMessage(dictionary);
   // PostMessage is asynchronous, so we should not receive a response yet.
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 0);
 
   // Break the cycles.
@@ skipping 166 matching lines @@
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }