Upstream version 5.34.104.0

[platform/framework/web/crosswalk.git] / src / ppapi / tests / test_post_message.cc

diff --git a/src/ppapi/tests/test_post_message.cc b/src/ppapi/tests/test_post_message.cc
index df126c7..085de33 100644 (file)
--- a/src/ppapi/tests/test_post_message.cc
+++ b/src/ppapi/tests/test_post_message.cc
@@ -9,10 +9,8 @@
 #include <map>
 #include <sstream>
 
-#include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_file_io.h"
-#include "ppapi/cpp/dev/var_resource_dev.h"
 #include "ppapi/cpp/file_io.h"
 #include "ppapi/cpp/file_ref.h"
 #include "ppapi/cpp/file_system.h"
@@ -128,7 +126,7 @@ bool VarsEqual(const pp::Var& expected,
 
 class ScopedArrayBufferSizeSetter {
  public:
-  ScopedArrayBufferSizeSetter(const PPB_Testing_Dev* interface,
+  ScopedArrayBufferSizeSetter(const PPB_Testing_Private* interface,
                               PP_Instance instance,
                               uint32_t threshold)
      : interface_(interface),
@@ -139,7 +137,7 @@ class ScopedArrayBufferSizeSetter {
     interface_->SetMinimumArrayBufferSizeForShmem(instance_, 0);
   }
  private:
-  const PPB_Testing_Dev* interface_;
+  const PPB_Testing_Private* interface_;
   PP_Instance instance_;
 };
 
@@ -319,8 +317,8 @@ std::string TestPostMessage::CheckMessageProperties(
     ASSERT_TRUE(AddEchoingListener(*iter));
     message_data_.clear();
     instance_->PostMessage(test_data);
-    ASSERT_EQ(message_data_.size(), 0);
-    ASSERT_EQ(WaitForMessages(), 1);
+    ASSERT_EQ(0, message_data_.size());
+    ASSERT_EQ(1, WaitForMessages());
     ASSERT_TRUE(message_data_.back().is_bool());
     if (!message_data_.back().AsBool())
       return std::string("Failed: ") + *iter;
@@ -331,11 +329,11 @@ std::string TestPostMessage::CheckMessageProperties(
 }
 
 std::string TestPostMessage::TestSendInInit() {
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(1, WaitForMessages());
   // This test assumes Init already sent a message.
-  ASSERT_EQ(message_data_.size(), 1);
+  ASSERT_EQ(1, message_data_.size());
   ASSERT_TRUE(message_data_.back().is_string());
-  ASSERT_EQ(message_data_.back().AsString(), kTestString);
+  ASSERT_EQ(kTestString, message_data_.back().AsString());
   message_data_.clear();
   PASS();
 }
@@ -355,43 +353,43 @@ std::string TestPostMessage::TestSendingData() {
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestString));
   // PostMessage is asynchronous, so we should not receive a response yet.
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_string());
   ASSERT_EQ(message_data_.back().AsString(), kTestString);
 
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestBool));
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_bool());
   ASSERT_EQ(message_data_.back().AsBool(), kTestBool);
 
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestInt));
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_number());
-  ASSERT_DOUBLE_EQ(message_data_.back().AsDouble(),
-                   static_cast<double>(kTestInt));
+  ASSERT_DOUBLE_EQ(static_cast<double>(kTestInt),
+                   message_data_.back().AsDouble());
 
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestDouble));
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_number());
   ASSERT_DOUBLE_EQ(message_data_.back().AsDouble(), kTestDouble);
 
   message_data_.clear();
   instance_->PostMessage(pp::Var());
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_undefined());
 
   message_data_.clear();
   instance_->PostMessage(pp::Var(pp::Var::Null()));
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_null());
 
   message_data_.clear();
@@ -457,8 +455,8 @@ std::string TestPostMessage::TestSendingArrayBuffer() {
     message_data_.clear();
     instance_->PostMessage(test_data);
     // PostMessage is asynchronous, so we should not receive a response yet.
-    ASSERT_EQ(message_data_.size(), 0);
-    ASSERT_EQ(WaitForMessages(), 1);
+    ASSERT_EQ(0, message_data_.size());
+    ASSERT_EQ(1, WaitForMessages());
     ASSERT_TRUE(message_data_.back().is_array_buffer());
     pp::VarArrayBuffer received(message_data_.back());
     message_data_.clear();
@@ -511,8 +509,8 @@ std::string TestPostMessage::TestSendingArray() {
   message_data_.clear();
   instance_->PostMessage(array);
   // PostMessage is asynchronous, so we should not receive a response yet.
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_array());
   ASSERT_TRUE(VarsEqual(array, message_data_.back()));
 
@@ -555,8 +553,8 @@ std::string TestPostMessage::TestSendingDictionary() {
   message_data_.clear();
   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_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_dictionary());
   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
 
@@ -578,7 +576,7 @@ std::string TestPostMessage::TestSendingResource() {
   // This opens a real (temporary) file using the HTML5 FileSystem API and
   // writes to it.
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
-  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(0, message_data_.size());
   std::string js_code =
       "function(callback) {"
       "  window.webkitRequestFileSystem(window.TEMPORARY, 1024,"
@@ -600,8 +598,7 @@ std::string TestPostMessage::TestSendingResource() {
   ASSERT_EQ(PostAsyncMessageFromJavaScriptAndWait(js_code), 1);
   pp::Var var = message_data_.back();
   ASSERT_TRUE(var.is_resource());
-  pp::VarResource_Dev var_resource(var);
-  pp::Resource result = var_resource.AsResource();
+  pp::Resource result = var.AsResource();
   ASSERT_TRUE(pp::FileSystem::IsFileSystem(result));
   {
     pp::FileSystem file_system(result);
@@ -678,8 +675,8 @@ std::string TestPostMessage::TestSendingComplexVar() {
   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_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_dictionary());
   pp::VarDictionary result(message_data_.back());
   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
@@ -697,7 +694,7 @@ std::string TestPostMessage::TestSendingComplexVar() {
   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(0, message_data_.size());
   ASSERT_EQ(WaitForMessages(), 0);
 
   // Break the cycles.
@@ -710,7 +707,7 @@ std::string TestPostMessage::TestSendingComplexVar() {
   // Test sending a cycle from JavaScript to the plugin.
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
   PostMessageFromJavaScript("function() { var x = []; x[0] = x; return x; }");
-  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(0, message_data_.size());
   ASSERT_EQ(WaitForMessages(), 0);
 
   WaitForMessages();
@@ -731,8 +728,8 @@ std::string TestPostMessage::TestMessageEvent() {
   ASSERT_TRUE(AddEchoingListener("message_event.constructor.name"));
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestInt));
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_string());
   ASSERT_EQ(message_data_.back().AsString(), "MessageEvent");
   ASSERT_TRUE(ClearListeners());
@@ -748,8 +745,8 @@ std::string TestPostMessage::TestMessageEvent() {
   ASSERT_TRUE(success);
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestInt));
-  ASSERT_EQ(message_data_.size(), 0);
-  ASSERT_EQ(WaitForMessages(), 1);
+  ASSERT_EQ(0, message_data_.size());
+  ASSERT_EQ(1, WaitForMessages());
   ASSERT_TRUE(message_data_.back().is_bool());
   ASSERT_TRUE(message_data_.back().AsBool());
   ASSERT_TRUE(ClearListeners());
@@ -762,7 +759,7 @@ std::string TestPostMessage::TestMessageEvent() {
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestInt));
   // Make sure we don't get a response in a re-entrant fashion.
-  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(0, message_data_.size());
   // We should get 3 messages.
   ASSERT_EQ(WaitForMessages(), 3);
   // Copy to a vector of doubles and sort; w3c does not specify the order for
@@ -845,7 +842,7 @@ std::string TestPostMessage::TestNonMainThread() {
     PP_JoinThread(threads[i]);
 
   // PostMessage is asynchronous, so we should not receive a response yet.
-  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(0, message_data_.size());
 
   // Make sure we got all values that we expected.  Note that because it's legal
   // for the JavaScript engine to treat our integers as floating points, we
@@ -856,7 +853,7 @@ std::string TestPostMessage::TestNonMainThread() {
   std::vector<int32_t> expected_counts(kThreadsToRun + 1,
                                        kMessagesToSendPerThread);
   std::vector<int32_t> received_counts(kThreadsToRun + 1, 0);
-  ASSERT_EQ(WaitForMessages(), expected_num);
+  ASSERT_EQ(expected_num, WaitForMessages());
   for (int32_t i = 0; i < expected_num; ++i) {
     const pp::Var& latest_var(message_data_[i]);
     ASSERT_TRUE(latest_var.is_int() || latest_var.is_double());
@@ -870,7 +867,7 @@ std::string TestPostMessage::TestNonMainThread() {
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
-  ASSERT_EQ(received_counts, expected_counts);
+  ASSERT_EQ(expected_counts, received_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());