Pepper: PPB_VideoDecoder software-only mode.

ppapi/proxy/video_decoder_resource_unittest.cc

 // Copyright 2014 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 <GLES2/gl2.h>
 
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_video_decoder.h"
 #include "ppapi/proxy/locking_resource_releaser.h"
 #include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/ppapi_message_utils.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
 #include "ppapi/proxy/video_decoder_constants.h"
 #include "ppapi/proxy/video_decoder_resource.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::proxy::ResourceMessageTestSink;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
-const PP_Bool kAllowSoftwareFallback = PP_TRUE;
 const PP_Resource kGraphics3D = 7;
 const uint32_t kShmSize = 256;
 const size_t kDecodeBufferSize = 16;
 const uint32_t kDecodeId = 5;
 const uint32_t kTextureId1 = 1;
 const uint32_t kTextureId2 = 2;
 const uint32_t kNumRequestedTextures = 2;
 
 class MockCompletionCallback {
  public:
@@ skipping 12 matching lines @@
   }
 
  private:
   bool called_;
   int32_t result_;
 };
 
 class VideoDecoderResourceTest : public PluginProxyTest {
  public:
   VideoDecoderResourceTest()
-      : decoder_iface_(thunk::GetPPB_VideoDecoder_0_1_Thunk()) {}
+      : decoder_iface_(thunk::GetPPB_VideoDecoder_0_2_Thunk()) {}
 
-  const PPB_VideoDecoder_0_1* decoder_iface() const { return decoder_iface_; }
+  const PPB_VideoDecoder_0_2* decoder_iface() const { return decoder_iface_; }
 
   void SendReply(const ResourceMessageCallParams& params,
                  int32_t result,
                  const IPC::Message& nested_message) {
     ResourceMessageReplyParams reply_params(params.pp_resource(),
                                             params.sequence());
     reply_params.set_result(result);
     PluginMessageFilter::DispatchResourceReplyForTest(reply_params,
                                                       nested_message);
   }
@@ skipping 35 matching lines @@
   }
 
   PP_Resource CreateAndInitializeDecoder() {
     PP_Resource decoder = CreateDecoder();
     LockingResourceReleaser graphics3d(CreateGraphics3d());
     MockCompletionCallback cb;
     int32_t result = decoder_iface()->Initialize(
         decoder,
         graphics3d.get(),
         PP_VIDEOPROFILE_H264MAIN,
-        PP_TRUE /* allow_software_fallback */,
+        PP_HARDWAREACCELERATION_WITHFALLBACK,
         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
                                           &cb));
     if (result != PP_OK_COMPLETIONPENDING)
       return 0;
     ResourceMessageCallParams params;
     IPC::Message msg;
     if (!sink().GetFirstResourceCallMatching(
             PpapiHostMsg_VideoDecoder_Initialize::ID, &params, &msg))
       return 0;
     sink().ClearMessages();
@@ skipping 161 matching lines @@
 
  private:
   bool CheckMsg(ResourceMessageCallParams* params, int id) {
     IPC::Message msg;
     if (!sink().GetFirstResourceCallMatching(id, params, &msg))
       return false;
     sink().ClearMessages();
     return true;
   }
 
-  const PPB_VideoDecoder_0_1* decoder_iface_;
+  const PPB_VideoDecoder_0_2* decoder_iface_;
 
   char decode_buffer_[kDecodeBufferSize];
 };
 
 }  // namespace
 
 TEST_F(VideoDecoderResourceTest, Initialize) {
   // Initialize with 0 graphics3d_context should fail.
   {
     LockingResourceReleaser decoder(CreateDecoder());
     MockCompletionCallback cb;
     int32_t result = decoder_iface()->Initialize(
         decoder.get(),
         0 /* invalid 3d graphics */,
         PP_VIDEOPROFILE_H264MAIN,
-        kAllowSoftwareFallback,
+        PP_HARDWAREACCELERATION_WITHFALLBACK,
         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
                                           &cb));
     ASSERT_EQ(PP_ERROR_BADRESOURCE, result);
   }
   // Initialize with bad profile value should fail.
   {
     LockingResourceReleaser decoder(CreateDecoder());
     MockCompletionCallback cb;
     int32_t result = decoder_iface()->Initialize(
         decoder.get(),
         1 /* non-zero resource */,
         static_cast<PP_VideoProfile>(-1),
-        kAllowSoftwareFallback,
+        PP_HARDWAREACCELERATION_WITHFALLBACK,
         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
                                           &cb));
     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
   }
   // Initialize with valid graphics3d_context and profile should succeed.
   {
     LockingResourceReleaser decoder(CreateDecoder());
     LockingResourceReleaser graphics3d(CreateGraphics3d());
     MockCompletionCallback cb;
     int32_t result = decoder_iface()->Initialize(
         decoder.get(),
         graphics3d.get(),
         PP_VIDEOPROFILE_H264MAIN,
-        kAllowSoftwareFallback,
+        PP_HARDWAREACCELERATION_WITHFALLBACK,
         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
                                           &cb));
     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
     ASSERT_TRUE(decoder_iface()->IsVideoDecoder(decoder.get()));
 
     // Another attempt while pending should fail.
     result = decoder_iface()->Initialize(
         decoder.get(),
         graphics3d.get(),
         PP_VIDEOPROFILE_H264MAIN,
-        kAllowSoftwareFallback,
+        PP_HARDWAREACCELERATION_WITHFALLBACK,
         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
                                           &cb));
     ASSERT_EQ(PP_ERROR_INPROGRESS, result);
 
     // Check for host message and send a reply to complete initialization.
     ResourceMessageCallParams params;
     IPC::Message msg;
     ASSERT_TRUE(sink().GetFirstResourceCallMatching(
         PpapiHostMsg_VideoDecoder_Initialize::ID, &params, &msg));
     sink().ClearMessages();
@@ skipping 207 matching lines @@
   ASSERT_FALSE(uncalled_cb.called());
   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED, CallFlush(decoder.get(), &uncalled_cb));
   ASSERT_FALSE(uncalled_cb.called());
   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED, CallReset(decoder.get(), &uncalled_cb));
   ASSERT_FALSE(uncalled_cb.called());
 }
 #endif  // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
 
 }  // namespace proxy
 }  // namespace ppapi