PPAPI: Move PPB_ArrayBuffer 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 <sstream>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_var.h"
-#include "ppapi/cpp/dev/var_array_buffer_dev.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/var.h"
+#include "ppapi/cpp/var_array_buffer.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 228 matching lines @@
 
   // TODO(sehr,dmichael): Add testing of longer array buffers when
   // crbug.com/110086 is fixed.
   uint32_t sizes[] = { 0, 100, 1000, 10000, 100000 };
   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_Dev test_data(sizes[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
     // detect if it's unmapped, so we just re-map before getting the pointer to
     // the buffer).
     test_data.Unmap();
     test_data.Map();
     ASSERT_EQ(sizes[i], test_data.ByteLength());
     unsigned char* buff = static_cast<unsigned char*>(test_data.Map());
     const uint32_t kByteLength = test_data.ByteLength();
@@ skipping 32 matching lines @@
 
     // 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"));
     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_TRUE(message_data_.back().is_array_buffer());
-    pp::VarArrayBuffer_Dev received(message_data_.back());
+    pp::VarArrayBuffer received(message_data_.back());
     message_data_.clear();
     ASSERT_EQ(test_data.ByteLength(), received.ByteLength());
     unsigned char* received_buff = static_cast<unsigned char*>(received.Map());
     // The buffer should be copied, so this should be a distinct buffer. When
     // 'transferrables' are implemented for PPAPI, we'll also want to test that
     // we get the _same_ buffer back when it's transferred.
     if (sizes[i] > 0)
       ASSERT_NE(buff, received_buff);
     for (size_t i = 0; i < test_data.ByteLength(); ++i)
       ASSERT_EQ(buff[i], received_buff[i]);
@@ skipping 155 matching lines @@
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }