Add PPAPI tests for VideoSource and VideoDestination resources.

ppapi/tests/test_video_source.cc

+// Copyright (c) 2013 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.
+//
+// Tests PPB_VideoSource_Private interface.
+
+#include "ppapi/tests/test_video_source.h"
+
+#include <string.h>

[Ronghua Wu (Left Chromium), 2013/05/09 22:22:52]

string?

[bbudge, 2013/05/09 22:35:35]

Done.

+#include <algorithm>
+#include <limits>
+
+#include "ppapi/c/dev/ppb_testing_dev.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/private/video_frame_private.h"
+#include "ppapi/cpp/private/video_source_private.h"
+#include "ppapi/cpp/var.h"
+#include "ppapi/tests/test_utils.h"
+#include "ppapi/tests/testing_instance.h"
+
+REGISTER_TEST_CASE(VideoSource);
+
+namespace {
+
+const PP_Resource kInvalidResource = 0;
+const PP_Instance kInvalidInstance = 0;
+
+}
+
+TestVideoSource::TestVideoSource(TestingInstance* instance)
+    : TestCase(instance),
+      ppb_video_source_private_interface_(NULL),
+      ppb_core_interface_(NULL),
+      event_(instance_->pp_instance()) {
+}
+
+bool TestVideoSource::Init() {
+  ppb_video_source_private_interface_ =
+      static_cast<const PPB_VideoSource_Private*>(
+          pp::Module::Get()->GetBrowserInterface(
+                                 PPB_VIDEOSOURCE_PRIVATE_INTERFACE));
+  ppb_core_interface_ = static_cast<const PPB_Core*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
+  if (!ppb_video_source_private_interface_)
+    instance_->AppendError("PPB_VideoSource_Private interface not available");
+  if (!ppb_core_interface_)
+    instance_->AppendError("PPB_Core interface not available");
+
+  return true;
+}
+
+TestVideoSource::~TestVideoSource() {
+}
+
+void TestVideoSource::RunTests(const std::string& filter) {
+  RUN_TEST(Create, filter);
+  RUN_TEST(GetFrame, filter);
+}
+
+void TestVideoSource::HandleMessage(const pp::Var& message_data) {
+  if (message_data.AsString().find("blob:") == 0) {
+    stream_url_ = message_data.AsString();
+    event_.Signal();
+  }
+}
+
+std::string TestVideoSource::TestCreate() {
+  PP_Resource video_source;
+  // Creating a source from an invalid instance returns an invalid resource.
+  video_source = ppb_video_source_private_interface_->Create(kInvalidInstance);
+  ASSERT_EQ(kInvalidResource, video_source);
+  ASSERT_FALSE(
+      ppb_video_source_private_interface_->IsVideoSource(video_source));
+
+  // Creating a source from a valid instance returns a valid resource.
+  video_source =
+      ppb_video_source_private_interface_->Create(instance_->pp_instance());
+  ASSERT_NE(kInvalidResource, video_source);
+  ASSERT_TRUE(
+      ppb_video_source_private_interface_->IsVideoSource(video_source));
+
+  ppb_core_interface_->ReleaseResource(video_source);
+  // Once released, the resource shouldn't be a video source.
+  ASSERT_FALSE(
+      ppb_video_source_private_interface_->IsVideoSource(video_source));
+
+  PASS();
+}
+
+std::string TestVideoSource::TestGetFrame() {
+  {
+    std::string js_code;
+    js_code += "var test_stream;"
+               "function gotStream(stream){"
+               "  test_stream = stream;"
+               "  var url = webkitURL.createObjectURL(test_stream);"
+               "  var plugin = document.getElementById('plugin');"
+               "  plugin.postMessage(url);"
+               "}"
+               "navigator.webkitGetUserMedia("
+               "{audio:false, video:true}, gotStream, function() {});";
+    instance_->EvalScript(js_code);
+    event_.Wait();
+
+    pp::VideoSource_Private video_source(instance_);
+    TestCompletionCallback cc1(instance_->pp_instance(), false);
+    cc1.WaitForResult(video_source.Open(stream_url_, cc1.GetCallback()));
+    ASSERT_EQ(PP_OK, cc1.result());
+    TestCompletionCallbackWithOutput<pp::VideoFrame_Private> cc2(
+        instance_->pp_instance(), false);
+    cc2.WaitForResult(video_source.GetFrame(cc2.GetCallback()));
+    ASSERT_EQ(PP_OK, cc2.result());
+    const pp::VideoFrame_Private video_frame = cc2.output();
+    ASSERT_FALSE(video_frame.image_data().is_null());
+
+    video_source.Close();
+  }
+
+  PASS();
+}
+