Hookup RawVarData to SerializedVar

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 <sstream>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
@@ skipping 40 matching lines @@
 };
 
 void InvokePostMessageThreadFunc(void* user_data) {
   InvokePostMessageThreadArg* arg =
       static_cast<InvokePostMessageThreadArg*>(user_data);
   for (int32_t i = 0; i < kMessagesToSendPerThread; ++i)
     arg->instance->PostMessage(arg->value_to_send);
   delete arg;
 }
 
+class ScopedArrayBufferSizeSetter {
+ public:
+  ScopedArrayBufferSizeSetter(const PPB_Testing_Dev* interface,
+                              PP_Instance instance,
+                              uint32_t threshold)
+     : interface_(interface),
+       instance_(instance) {
+    interface_->SetMinimumArrayBufferSizeForShmem(instance_, threshold);
+  }
+  ~ScopedArrayBufferSizeSetter() {
+    interface_->SetMinimumArrayBufferSizeForShmem(instance_, 0);
+  }
+ private:
+  const PPB_Testing_Dev* interface_;
+  PP_Instance instance_;
+};
+
 #define FINISHED_WAITING_MESSAGE "TEST_POST_MESSAGE_FINISHED_WAITING"
 
 }  // namespace
 
 TestPostMessage::TestPostMessage(TestingInstance* instance)
     : TestCase(instance) {
 }
 
 TestPostMessage::~TestPostMessage() {
   // Remove the special listener that only responds to a FINISHED_WAITING
@@ skipping 183 matching lines @@
 
 std::string TestPostMessage::TestSendingArrayBuffer() {
   // 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());
 
   // TODO(sehr,dmichael): Add testing of longer array buffers when
   // crbug.com/110086 is fixed.
-#if defined(OS_LINUX)
-  uint32_t sizes[] = { 0, 100, 1000, 10000, 100000, 1000000 };
-#else
-  uint32_t sizes[] = { 0, 100, 1000, 10000, 100000  };
-#endif
+  ScopedArrayBufferSizeSetter setter(testing_interface_,
+                                     instance_->pp_instance(),
+                                     200);
+  uint32_t sizes[] = { 0, 100, 1000, 10000 };
   for (size_t i = 0; i < sizeof(sizes)/sizeof(sizes[i]); ++i) {
     std::ostringstream size_stream;
     size_stream << sizes[i];
     const std::string kSizeAsString(size_stream.str());
 
     // Create an appropriately sized array buffer with test_data[i] == i.
     pp::VarArrayBuffer test_data(sizes[i]);
     if (sizes[i] > 0)
       ASSERT_NE(NULL, test_data.Map());
     // Make sure we can Unmap/Map successfully (there's not really any way to
@@ skipping 215 matching lines @@
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }