Add 4 VP9 profiles to the media::VideoCodecProfile enum.

ppapi/tests/test_video_encoder.cc

 // Copyright 2015 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_video_encoder.h"
 
 #include "ppapi/c/pp_codecs.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/video_encoder.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(VideoEncoder);
 
 bool TestVideoEncoder::Init() {
   video_encoder_interface_ = static_cast<const PPB_VideoEncoder_0_1*>(
       pp::Module::Get()->GetBrowserInterface(PPB_VIDEOENCODER_INTERFACE_0_1));
   return video_encoder_interface_ && CheckTestingInterface();
 }
 
 void TestVideoEncoder::RunTests(const std::string& filter) {
   RUN_CALLBACK_TEST(TestVideoEncoder, AvailableCodecs, filter);
   RUN_CALLBACK_TEST(TestVideoEncoder, IncorrectSizeFails, filter);
   RUN_CALLBACK_TEST(TestVideoEncoder, InitializeVP8, filter);
-  RUN_CALLBACK_TEST(TestVideoEncoder, InitializeVP9, filter);
+  RUN_CALLBACK_TEST(TestVideoEncoder, InitializeVP9_Profile0, filter);
+  RUN_CALLBACK_TEST(TestVideoEncoder, InitializeVP9_Profile1, filter);
+  RUN_CALLBACK_TEST(TestVideoEncoder, InitializeVP9_Profile2, filter);
+  RUN_CALLBACK_TEST(TestVideoEncoder, InitializeVP9_Profile3, filter);
 }
 
 std::string TestVideoEncoder::TestAvailableCodecs() {

[ddorwin, 2016/03/25 22:51:22]

Should this test have ifdef'd tests for H.264? (Not in this CL, but is this
something missing?)

[servolk, 2016/03/25 23:52:01]

The only H.264 encoder that I could find in Chrome is webrtc::H264Encoder and
that doesn't seem to work through PPAPI, so H.264 tests should be added only
after adding PPAPI-compatible H.264 encoder.

[ddorwin, 2016/03/26 00:45:08]

Thanks for checking.

   // Test that we get results for supported formats. We should at
   // least get the software supported formats.
   pp::VideoEncoder video_encoder(instance_);
   ASSERT_FALSE(video_encoder.is_null());
 
   TestCompletionCallbackWithOutput<std::vector<PP_VideoProfileDescription> >
       callback(instance_->pp_instance(), false);
   callback.WaitForResult(
       video_encoder.GetSupportedProfiles(callback.GetCallback()));
 
   ASSERT_GE(callback.result(), 1U);
 
   const std::vector<PP_VideoProfileDescription> video_profiles =
       callback.output();
   ASSERT_GE(video_profiles.size(), 1U);
 
-  bool found_vp8 = false, found_vp9 = false;
+  bool found_vp8 = false;
+  uint8_t found_vp9_profiles = 0;
   for (uint32_t i = 0; i < video_profiles.size(); ++i) {
     const PP_VideoProfileDescription& description = video_profiles[i];
     if (description.hardware_accelerated == PP_FALSE) {
       ASSERT_GE(description.max_framerate_numerator /
                     description.max_framerate_denominator,
                 30U);
       if (description.profile == PP_VIDEOPROFILE_VP8_ANY)
         found_vp8 = true;
-      else if (description.profile == PP_VIDEOPROFILE_VP9_ANY)
-        found_vp9 = true;
+      else if (description.profile == PP_VIDEOPROFILE_VP9_PROFILE0)
+        found_vp9_profiles |= 1;
+      else if (description.profile == PP_VIDEOPROFILE_VP9_PROFILE1)
+        found_vp9_profiles |= (1 << 1);
+      else if (description.profile == PP_VIDEOPROFILE_VP9_PROFILE2)
+        found_vp9_profiles |= (1 << 2);
+      else if (description.profile == PP_VIDEOPROFILE_VP9_PROFILE3)
+        found_vp9_profiles |= (1 << 3);
     }
   }
   ASSERT_TRUE(found_vp8);
-  ASSERT_TRUE(found_vp9);
+  ASSERT_EQ(0xf, found_vp9_profiles);
 
   PASS();
 }
 
 std::string TestVideoEncoder::TestIncorrectSizeFails() {
   // Test that initializing the encoder with incorrect size fails.
   pp::VideoEncoder video_encoder(instance_);
   ASSERT_FALSE(video_encoder.is_null());
   pp::Size video_size(0, 0);
 
   TestCompletionCallback callback(instance_->pp_instance(), false);
   callback.WaitForResult(video_encoder.Initialize(
       PP_VIDEOFRAME_FORMAT_I420, video_size, PP_VIDEOPROFILE_VP8_ANY, 1000000,
       PP_HARDWAREACCELERATION_WITHFALLBACK, callback.GetCallback()));
 
   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 
   PASS();
 }
 
 std::string TestVideoEncoder::TestInitializeVP8() {
   return TestInitializeCodec(PP_VIDEOPROFILE_VP8_ANY);
 }
 
-std::string TestVideoEncoder::TestInitializeVP9() {
-  return TestInitializeCodec(PP_VIDEOPROFILE_VP9_ANY);
+std::string TestVideoEncoder::TestInitializeVP9_Profile0() {
+  return TestInitializeCodec(PP_VIDEOPROFILE_VP9_PROFILE0);
+}
+
+std::string TestVideoEncoder::TestInitializeVP9_Profile1() {
+  return TestInitializeCodec(PP_VIDEOPROFILE_VP9_PROFILE1);
+}
+
+std::string TestVideoEncoder::TestInitializeVP9_Profile2() {
+  return TestInitializeCodec(PP_VIDEOPROFILE_VP9_PROFILE2);
+}
+
+std::string TestVideoEncoder::TestInitializeVP9_Profile3() {
+  return TestInitializeCodec(PP_VIDEOPROFILE_VP9_PROFILE2);

[ddorwin, 2016/03/25 22:51:22]

s/2/3/

[servolk, 2016/03/25 23:52:01]

Done.

 }
 
 std::string TestVideoEncoder::TestInitializeCodec(PP_VideoProfile profile) {
   pp::VideoEncoder video_encoder(instance_);
   ASSERT_FALSE(video_encoder.is_null());
   pp::Size video_size(640, 480);
 
   TestCompletionCallback callback(instance_->pp_instance(), false);
   callback.WaitForResult(video_encoder.Initialize(
       PP_VIDEOFRAME_FORMAT_I420, video_size, profile, 1000000,
@@ skipping 11 matching lines @@
   get_video_frame.WaitForResult(
       video_encoder.GetVideoFrame(get_video_frame.GetCallback()));
   ASSERT_EQ(PP_OK, get_video_frame.result());
 
   pp::Size video_frame_size;
   ASSERT_TRUE(get_video_frame.output().GetSize(&video_frame_size));
   ASSERT_EQ(coded_size.GetArea(), video_frame_size.GetArea());
 
   PASS();
 }