[PPAPI] Added VarResource_Dev class.

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 <string.h>
 #include <algorithm>
 #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"
 #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"
@@ skipping 135 matching lines @@
   js_code += "var plugin = document.getElementById('plugin');"
              "plugin.removeEventListener('message',"
              "                           plugin.wait_for_messages_handler);"
              "delete plugin.wait_for_messages_handler;";
   instance_->EvalScript(js_code);
 }
 
 bool TestPostMessage::Init() {
   bool success = CheckTestingInterface();
 
-  core_interface_ = static_cast<const PPB_Core*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
-  file_system_interface_ = static_cast<const PPB_FileSystem*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_FILESYSTEM_INTERFACE));
-  var_interface_ = static_cast<const PPB_Var*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
-  var_resource_interface_ = static_cast<const PPB_VarResource_Dev*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_VAR_RESOURCE_DEV_INTERFACE));
-  if (!core_interface_ || !file_system_interface_ || !var_interface_ ||
-      !var_resource_interface_)
-    return false;
-
   // Set up a special listener that only responds to a FINISHED_WAITING string.
   // This is for use by WaitForMessages.
   std::string js_code;
   // Note the following code is dependent on some features of test_case.html.
   // E.g., it is assumed that the DOM element where the plugin is embedded has
   // an id of 'plugin', and there is a function 'IsTestingMessage' that allows
   // us to ignore the messages that are intended for use by the testing
   // framework itself.
   js_code += "var plugin = document.getElementById('plugin');"
              "var wait_for_messages_handler = function(message_event) {"
@@ skipping 410 matching lines @@
       "        writer.onwriteend = function() { callback(fileSystem); };"
       "        var blob = new Blob(['";
   js_code += kTestString;
   js_code += "'], {'type': 'text/plain'});"
       "        writer.write(blob);"
       "      });"
       "    }, function() { callback(null); });"
       "  }, function() { callback(null); });"
       "}";
   ASSERT_EQ(PostAsyncMessageFromJavaScriptAndWait(js_code), 1);
-  // TODO(mgiuca): Use the C++ API instead of the C API, when it is available.
-  PP_Var var = message_data_.back().Detach();
-  PP_Resource result = var_resource_interface_->VarToResource(var);
-  ASSERT_TRUE(file_system_interface_->IsFileSystem(result));
+  pp::Var var = message_data_.back();
+  ASSERT_TRUE(var.is_resource());
+  pp::VarResource_Dev var_resource(var);
+  pp::Resource result = var_resource.AsResource();
+  ASSERT_TRUE(pp::FileSystem::IsFileSystem(result));
   {
-    pp::FileSystem file_system(pp::PASS_REF, result);
+    pp::FileSystem file_system(result);
     std::string file_path("/");
     file_path += kTestFilename;
     pp::FileRef file_ref(file_system, file_path.c_str());
     ASSERT_NE(0, file_ref.pp_resource());
 
     // Read the file and test that its contents match.
     pp::FileIO file_io(instance_);
     ASSERT_NE(0, file_io.pp_resource());
     TestCompletionCallback callback(instance_->pp_instance(),
                                     callback_type());
     callback.WaitForResult(
         file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_EQ(PP_OK, callback.result());
 
     int length = strlen(kTestString);
     std::vector<char> buffer_vector(length);
     char* buffer = &buffer_vector[0];  // Note: Not null-terminated!
     callback.WaitForResult(
         file_io.Read(0, buffer, length, callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_EQ(length, callback.result());
     ASSERT_EQ(0, memcmp(buffer, kTestString, length));
   }
-  var_interface_->Release(var);
 
   WaitForMessages();
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   // TODO(mgiuca): Test roundtrip from plugin to JS and back, when the plugin to
   // JS support is available.
 
   PASS();
 }
@@ skipping 221 matching lines @@
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }