Home | History | Annotate | Download | only in proxy 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <GLES2/gl2.h>
      6 
      7 #include "base/memory/shared_memory.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "ppapi/c/pp_errors.h"
     10 #include "ppapi/c/ppb_video_decoder.h"
     11 #include "ppapi/proxy/locking_resource_releaser.h"
     12 #include "ppapi/proxy/plugin_message_filter.h"
     13 #include "ppapi/proxy/ppapi_message_utils.h"
     14 #include "ppapi/proxy/ppapi_messages.h"
     15 #include "ppapi/proxy/ppapi_proxy_test.h"
     16 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
     17 #include "ppapi/proxy/video_decoder_constants.h"
     18 #include "ppapi/proxy/video_decoder_resource.h"
     19 #include "ppapi/shared_impl/proxy_lock.h"
     20 #include "ppapi/thunk/thunk.h"
     21 
     22 using ppapi::proxy::ResourceMessageTestSink;
     23 
     24 namespace ppapi {
     25 namespace proxy {
     26 
     27 namespace {
     28 
     29 const PP_Resource kGraphics3D = 7;
     30 const uint32_t kShmSize = 256;
     31 const size_t kDecodeBufferSize = 16;
     32 const uint32_t kDecodeId = 5;
     33 const uint32_t kTextureId1 = 1;
     34 const uint32_t kTextureId2 = 2;
     35 const uint32_t kNumRequestedTextures = 2;
     36 
     37 class MockCompletionCallback {
     38  public:
     39   MockCompletionCallback() : called_(false) {}
     40 
     41   bool called() { return called_; }
     42   int32_t result() { return result_; }
     43 
     44   void Reset() { called_ = false; }
     45 
     46   static void Callback(void* user_data, int32_t result) {
     47     MockCompletionCallback* that =
     48         reinterpret_cast<MockCompletionCallback*>(user_data);
     49     that->called_ = true;
     50     that->result_ = result;
     51   }
     52 
     53  private:
     54   bool called_;
     55   int32_t result_;
     56 };
     57 
     58 class VideoDecoderResourceTest : public PluginProxyTest {
     59  public:
     60   VideoDecoderResourceTest()
     61       : decoder_iface_(thunk::GetPPB_VideoDecoder_0_2_Thunk()) {}
     62 
     63   const PPB_VideoDecoder_0_2* decoder_iface() const { return decoder_iface_; }
     64 
     65   void SendReply(const ResourceMessageCallParams& params,
     66                  int32_t result,
     67                  const IPC::Message& nested_message) {
     68     ResourceMessageReplyParams reply_params(params.pp_resource(),
     69                                             params.sequence());
     70     reply_params.set_result(result);
     71     PluginMessageFilter::DispatchResourceReplyForTest(reply_params,
     72                                                       nested_message);
     73   }
     74 
     75   void SendReplyWithHandle(const ResourceMessageCallParams& params,
     76                            int32_t result,
     77                            const IPC::Message& nested_message,
     78                            const SerializedHandle& handle) {
     79     ResourceMessageReplyParams reply_params(params.pp_resource(),
     80                                             params.sequence());
     81     reply_params.set_result(result);
     82     reply_params.AppendHandle(handle);
     83     PluginMessageFilter::DispatchResourceReplyForTest(reply_params,
     84                                                       nested_message);
     85   }
     86 
     87   PP_Resource CreateDecoder() {
     88     PP_Resource result = decoder_iface()->Create(pp_instance());
     89     if (result) {
     90       ProxyAutoLock lock;
     91       ppapi::Resource* resource =
     92           GetGlobals()->GetResourceTracker()->GetResource(result);
     93       proxy::VideoDecoderResource* decoder =
     94           static_cast<proxy::VideoDecoderResource*>(resource);
     95       decoder->SetForTest();
     96     }
     97 
     98     return result;
     99   }
    100 
    101   PP_Resource CreateGraphics3d() {
    102     ProxyAutoLock lock;
    103 
    104     HostResource host_resource;
    105     host_resource.SetHostResource(pp_instance(), kGraphics3D);
    106     scoped_refptr<ppapi::proxy::Graphics3D> graphics_3d(
    107         new ppapi::proxy::Graphics3D(host_resource));
    108     return graphics_3d->GetReference();
    109   }
    110 
    111   PP_Resource CreateAndInitializeDecoder() {
    112     PP_Resource decoder = CreateDecoder();
    113     LockingResourceReleaser graphics3d(CreateGraphics3d());
    114     MockCompletionCallback cb;
    115     int32_t result = decoder_iface()->Initialize(
    116         decoder,
    117         graphics3d.get(),
    118         PP_VIDEOPROFILE_H264MAIN,
    119         PP_HARDWAREACCELERATION_WITHFALLBACK,
    120         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
    121                                           &cb));
    122     if (result != PP_OK_COMPLETIONPENDING)
    123       return 0;
    124     ResourceMessageCallParams params;
    125     IPC::Message msg;
    126     if (!sink().GetFirstResourceCallMatching(
    127             PpapiHostMsg_VideoDecoder_Initialize::ID, &params, &msg))
    128       return 0;
    129     sink().ClearMessages();
    130     SendReply(params, PP_OK, PpapiPluginMsg_VideoDecoder_InitializeReply());
    131     return decoder;
    132   }
    133 
    134   int32_t CallDecode(PP_Resource pp_decoder,
    135                      MockCompletionCallback* cb,
    136                      const PpapiHostMsg_VideoDecoder_GetShm* expected_shm_msg) {
    137     // Set up a handler in case the resource sends a sync message to create
    138     // shared memory.
    139     PpapiPluginMsg_VideoDecoder_GetShmReply shm_msg_reply(kShmSize);
    140     ResourceSyncCallHandler shm_msg_handler(
    141         &sink(), PpapiHostMsg_VideoDecoder_GetShm::ID, PP_OK, shm_msg_reply);
    142     sink().AddFilter(&shm_msg_handler);
    143 
    144     base::SharedMemory shm;
    145     if (expected_shm_msg) {
    146       shm.CreateAnonymous(kShmSize);
    147       base::SharedMemoryHandle shm_handle;
    148       shm.ShareToProcess(base::GetCurrentProcessHandle(), &shm_handle);
    149       SerializedHandle serialized_handle(shm_handle, kShmSize);
    150       shm_msg_handler.set_serialized_handle(&serialized_handle);
    151     }
    152 
    153     memset(decode_buffer_, 0x55, kDecodeBufferSize);
    154     int32_t result =
    155         decoder_iface()->Decode(pp_decoder,
    156                                 kDecodeId,
    157                                 kDecodeBufferSize,
    158                                 decode_buffer_,
    159                                 PP_MakeOptionalCompletionCallback(
    160                                     &MockCompletionCallback::Callback, cb));
    161 
    162     if (expected_shm_msg) {
    163       uint32_t shm_id, shm_size, expected_shm_id, expected_shm_size;
    164       UnpackMessage<PpapiHostMsg_VideoDecoder_GetShm>(
    165           *expected_shm_msg, &expected_shm_id, &expected_shm_size);
    166       if (shm_msg_handler.last_handled_msg().type() == 0 ||
    167           !UnpackMessage<PpapiHostMsg_VideoDecoder_GetShm>(
    168               shm_msg_handler.last_handled_msg(), &shm_id, &shm_size) ||
    169           shm_id != expected_shm_id ||
    170           shm_size != expected_shm_size) {
    171         // Signal that the expected shm message wasn't sent by failing.
    172         result = PP_ERROR_FAILED;
    173       }
    174     }
    175 
    176     sink().RemoveFilter(&shm_msg_handler);
    177     return result;
    178   }
    179 
    180   int32_t CallGetPicture(PP_Resource pp_decoder,
    181                          PP_VideoPicture* picture,
    182                          MockCompletionCallback* cb) {
    183     int32_t result =
    184         decoder_iface()->GetPicture(pp_decoder,
    185                                     picture,
    186                                     PP_MakeOptionalCompletionCallback(
    187                                         &MockCompletionCallback::Callback, cb));
    188     return result;
    189   }
    190 
    191   void CallRecyclePicture(PP_Resource pp_decoder,
    192                           const PP_VideoPicture& picture) {
    193     decoder_iface()->RecyclePicture(pp_decoder, &picture);
    194   }
    195 
    196   int32_t CallFlush(PP_Resource pp_decoder, MockCompletionCallback* cb) {
    197     int32_t result =
    198         decoder_iface()->Flush(pp_decoder,
    199                                PP_MakeOptionalCompletionCallback(
    200                                    &MockCompletionCallback::Callback, cb));
    201     return result;
    202   }
    203 
    204   int32_t CallReset(PP_Resource pp_decoder, MockCompletionCallback* cb) {
    205     int32_t result =
    206         decoder_iface()->Reset(pp_decoder,
    207                                PP_MakeOptionalCompletionCallback(
    208                                    &MockCompletionCallback::Callback, cb));
    209     return result;
    210   }
    211 
    212   void SendDecodeReply(const ResourceMessageCallParams& params,
    213                        uint32_t shm_id) {
    214     SendReply(params, PP_OK, PpapiPluginMsg_VideoDecoder_DecodeReply(shm_id));
    215   }
    216 
    217   void SendPictureReady(const ResourceMessageCallParams& params,
    218                         uint32_t decode_count,
    219                         uint32_t texture_id) {
    220     SendReply(
    221         params,
    222         PP_OK,
    223         PpapiPluginMsg_VideoDecoder_PictureReady(decode_count, texture_id));
    224   }
    225 
    226   void SendFlushReply(const ResourceMessageCallParams& params) {
    227     SendReply(params, PP_OK, PpapiPluginMsg_VideoDecoder_FlushReply());
    228   }
    229 
    230   void SendResetReply(const ResourceMessageCallParams& params) {
    231     SendReply(params, PP_OK, PpapiPluginMsg_VideoDecoder_ResetReply());
    232   }
    233 
    234   void SendRequestTextures(const ResourceMessageCallParams& params) {
    235     SendReply(params,
    236               PP_OK,
    237               PpapiPluginMsg_VideoDecoder_RequestTextures(
    238                   kNumRequestedTextures,
    239                   PP_MakeSize(320, 240),
    240                   GL_TEXTURE_2D,
    241                   std::vector<gpu::Mailbox>()));
    242   }
    243 
    244   void SendNotifyError(const ResourceMessageCallParams& params, int32_t error) {
    245     SendReply(params, PP_OK, PpapiPluginMsg_VideoDecoder_NotifyError(error));
    246   }
    247 
    248   bool CheckDecodeMsg(ResourceMessageCallParams* params,
    249                       uint32_t* shm_id,
    250                       uint32_t* size,
    251                       int32_t* decode_id) {
    252     IPC::Message msg;
    253     if (!sink().GetFirstResourceCallMatching(
    254             PpapiHostMsg_VideoDecoder_Decode::ID, params, &msg))
    255       return false;
    256     sink().ClearMessages();
    257     return UnpackMessage<PpapiHostMsg_VideoDecoder_Decode>(
    258         msg, shm_id, size, decode_id);
    259   }
    260 
    261   bool CheckRecyclePictureMsg(ResourceMessageCallParams* params,
    262                               uint32_t* texture_id) {
    263     IPC::Message msg;
    264     if (!sink().GetFirstResourceCallMatching(
    265             PpapiHostMsg_VideoDecoder_RecyclePicture::ID, params, &msg))
    266       return false;
    267     sink().ClearMessages();
    268     return UnpackMessage<PpapiHostMsg_VideoDecoder_RecyclePicture>(msg,
    269                                                                    texture_id);
    270   }
    271 
    272   bool CheckFlushMsg(ResourceMessageCallParams* params) {
    273     return CheckMsg(params, PpapiHostMsg_VideoDecoder_Flush::ID);
    274   }
    275 
    276   bool CheckResetMsg(ResourceMessageCallParams* params) {
    277     return CheckMsg(params, PpapiHostMsg_VideoDecoder_Reset::ID);
    278   }
    279 
    280   void ClearCallbacks(PP_Resource pp_decoder) {
    281     ResourceMessageCallParams params;
    282     MockCompletionCallback cb;
    283 
    284     // Reset to abort Decode and GetPicture callbacks.
    285     CallReset(pp_decoder, &cb);
    286     // Initialize params so we can reply to the Reset.
    287     CheckResetMsg(&params);
    288     // Run the Reset callback.
    289     SendResetReply(params);
    290   }
    291 
    292  private:
    293   bool CheckMsg(ResourceMessageCallParams* params, int id) {
    294     IPC::Message msg;
    295     if (!sink().GetFirstResourceCallMatching(id, params, &msg))
    296       return false;
    297     sink().ClearMessages();
    298     return true;
    299   }
    300 
    301   const PPB_VideoDecoder_0_2* decoder_iface_;
    302 
    303   char decode_buffer_[kDecodeBufferSize];
    304 };
    305 
    306 }  // namespace
    307 
    308 TEST_F(VideoDecoderResourceTest, Initialize) {
    309   // Initialize with 0 graphics3d_context should fail.
    310   {
    311     LockingResourceReleaser decoder(CreateDecoder());
    312     MockCompletionCallback cb;
    313     int32_t result = decoder_iface()->Initialize(
    314         decoder.get(),
    315         0 /* invalid 3d graphics */,
    316         PP_VIDEOPROFILE_H264MAIN,
    317         PP_HARDWAREACCELERATION_WITHFALLBACK,
    318         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
    319                                           &cb));
    320     ASSERT_EQ(PP_ERROR_BADRESOURCE, result);
    321   }
    322   // Initialize with bad profile value should fail.
    323   {
    324     LockingResourceReleaser decoder(CreateDecoder());
    325     MockCompletionCallback cb;
    326     int32_t result = decoder_iface()->Initialize(
    327         decoder.get(),
    328         1 /* non-zero resource */,
    329         static_cast<PP_VideoProfile>(-1),
    330         PP_HARDWAREACCELERATION_WITHFALLBACK,
    331         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
    332                                           &cb));
    333     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
    334   }
    335   // Initialize with valid graphics3d_context and profile should succeed.
    336   {
    337     LockingResourceReleaser decoder(CreateDecoder());
    338     LockingResourceReleaser graphics3d(CreateGraphics3d());
    339     MockCompletionCallback cb;
    340     int32_t result = decoder_iface()->Initialize(
    341         decoder.get(),
    342         graphics3d.get(),
    343         PP_VIDEOPROFILE_H264MAIN,
    344         PP_HARDWAREACCELERATION_WITHFALLBACK,
    345         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
    346                                           &cb));
    347     ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
    348     ASSERT_TRUE(decoder_iface()->IsVideoDecoder(decoder.get()));
    349 
    350     // Another attempt while pending should fail.
    351     result = decoder_iface()->Initialize(
    352         decoder.get(),
    353         graphics3d.get(),
    354         PP_VIDEOPROFILE_H264MAIN,
    355         PP_HARDWAREACCELERATION_WITHFALLBACK,
    356         PP_MakeOptionalCompletionCallback(&MockCompletionCallback::Callback,
    357                                           &cb));
    358     ASSERT_EQ(PP_ERROR_INPROGRESS, result);
    359 
    360     // Check for host message and send a reply to complete initialization.
    361     ResourceMessageCallParams params;
    362     IPC::Message msg;
    363     ASSERT_TRUE(sink().GetFirstResourceCallMatching(
    364         PpapiHostMsg_VideoDecoder_Initialize::ID, &params, &msg));
    365     sink().ClearMessages();
    366     SendReply(params, PP_OK, PpapiPluginMsg_VideoDecoder_InitializeReply());
    367     ASSERT_TRUE(cb.called());
    368     ASSERT_EQ(PP_OK, cb.result());
    369   }
    370 }
    371 
    372 TEST_F(VideoDecoderResourceTest, Uninitialized) {
    373   // Operations on uninitialized decoders should fail.
    374   LockingResourceReleaser decoder(CreateDecoder());
    375   MockCompletionCallback uncalled_cb;
    376 
    377   ASSERT_EQ(PP_ERROR_FAILED, CallDecode(decoder.get(), &uncalled_cb, NULL));
    378   ASSERT_FALSE(uncalled_cb.called());
    379 
    380   ASSERT_EQ(PP_ERROR_FAILED, CallGetPicture(decoder.get(), NULL, &uncalled_cb));
    381   ASSERT_FALSE(uncalled_cb.called());
    382 
    383   ASSERT_EQ(PP_ERROR_FAILED, CallFlush(decoder.get(), &uncalled_cb));
    384   ASSERT_FALSE(uncalled_cb.called());
    385 
    386   ASSERT_EQ(PP_ERROR_FAILED, CallReset(decoder.get(), &uncalled_cb));
    387   ASSERT_FALSE(uncalled_cb.called());
    388 }
    389 
    390 // TODO(bbudge) Fix sync message testing on Windows 64 bit builds. The reply
    391 // message for GetShm isn't received, causing Decode to fail.
    392 // http://crbug.com/379260
    393 #if !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
    394 TEST_F(VideoDecoderResourceTest, DecodeAndGetPicture) {
    395   LockingResourceReleaser decoder(CreateAndInitializeDecoder());
    396   ResourceMessageCallParams params, params2;
    397   MockCompletionCallback decode_cb, get_picture_cb, uncalled_cb;
    398 
    399   uint32_t shm_id;
    400   uint32_t decode_size;
    401   int32_t decode_id;
    402   // Call Decode until we have the maximum pending, minus one.
    403   for (uint32_t i = 0; i < kMaximumPendingDecodes - 1; i++) {
    404     PpapiHostMsg_VideoDecoder_GetShm shm_msg(i, kDecodeBufferSize);
    405     ASSERT_EQ(PP_OK, CallDecode(decoder.get(), &uncalled_cb, &shm_msg));
    406     ASSERT_FALSE(uncalled_cb.called());
    407     CheckDecodeMsg(&params, &shm_id, &decode_size, &decode_id);
    408     ASSERT_EQ(i, shm_id);
    409     ASSERT_EQ(kDecodeBufferSize, decode_size);
    410     // The resource generates uids internally, starting at 1.
    411     int32_t uid = i + 1;
    412     ASSERT_EQ(uid, decode_id);
    413   }
    414   // Once we've allocated the maximum number of buffers, we must wait.
    415   PpapiHostMsg_VideoDecoder_GetShm shm_msg(7U, kDecodeBufferSize);
    416   ASSERT_EQ(PP_OK_COMPLETIONPENDING,
    417             CallDecode(decoder.get(), &decode_cb, &shm_msg));
    418   CheckDecodeMsg(&params, &shm_id, &decode_size, &decode_id);
    419   ASSERT_EQ(7U, shm_id);
    420   ASSERT_EQ(kDecodeBufferSize, decode_size);
    421 
    422   // Calling Decode when another Decode is pending should fail.
    423   ASSERT_EQ(PP_ERROR_INPROGRESS, CallDecode(decoder.get(), &uncalled_cb, NULL));
    424   ASSERT_FALSE(uncalled_cb.called());
    425   // Free up the first decode buffer.
    426   SendDecodeReply(params, 0U);
    427   // The decoder should run the pending callback.
    428   ASSERT_TRUE(decode_cb.called());
    429   ASSERT_EQ(PP_OK, decode_cb.result());
    430   decode_cb.Reset();
    431 
    432   // Now try to get a picture. No picture ready message has been received yet.
    433   PP_VideoPicture picture;
    434   ASSERT_EQ(PP_OK_COMPLETIONPENDING,
    435             CallGetPicture(decoder.get(), &picture, &get_picture_cb));
    436   ASSERT_FALSE(get_picture_cb.called());
    437   // Calling GetPicture when another GetPicture is pending should fail.
    438   ASSERT_EQ(PP_ERROR_INPROGRESS,
    439             CallGetPicture(decoder.get(), &picture, &uncalled_cb));
    440   ASSERT_FALSE(uncalled_cb.called());
    441   // Send 'request textures' message to initialize textures.
    442   SendRequestTextures(params);
    443   // Send a picture ready message for Decode call 1. The GetPicture callback
    444   // should complete.
    445   SendPictureReady(params, 1U, kTextureId1);
    446   ASSERT_TRUE(get_picture_cb.called());
    447   ASSERT_EQ(PP_OK, get_picture_cb.result());
    448   ASSERT_EQ(kDecodeId, picture.decode_id);
    449   get_picture_cb.Reset();
    450 
    451   // Send a picture ready message for Decode call 2. Since there is no pending
    452   // GetPicture call, the picture should be queued.
    453   SendPictureReady(params, 2U, kTextureId2);
    454   // The next GetPicture should return synchronously.
    455   ASSERT_EQ(PP_OK, CallGetPicture(decoder.get(), &picture, &uncalled_cb));
    456   ASSERT_FALSE(uncalled_cb.called());
    457   ASSERT_EQ(kDecodeId, picture.decode_id);
    458 }
    459 #endif  // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
    460 
    461 // TODO(bbudge) Fix sync message testing on Windows 64 bit builds. The reply
    462 // message for GetShm isn't received, causing Decode to fail.
    463 // http://crbug.com/379260
    464 #if !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
    465 TEST_F(VideoDecoderResourceTest, RecyclePicture) {
    466   LockingResourceReleaser decoder(CreateAndInitializeDecoder());
    467   ResourceMessageCallParams params;
    468   MockCompletionCallback decode_cb, get_picture_cb, uncalled_cb;
    469 
    470   // Get to a state where we have a picture to recycle.
    471   PpapiHostMsg_VideoDecoder_GetShm shm_msg(0U, kDecodeBufferSize);
    472   ASSERT_EQ(PP_OK, CallDecode(decoder.get(), &decode_cb, &shm_msg));
    473   uint32_t shm_id;
    474   uint32_t decode_size;
    475   int32_t decode_id;
    476   CheckDecodeMsg(&params, &shm_id, &decode_size, &decode_id);
    477   SendDecodeReply(params, 0U);
    478   // Send 'request textures' message to initialize textures.
    479   SendRequestTextures(params);
    480   // Call GetPicture and send 'picture ready' message to get a picture to
    481   // recycle.
    482   PP_VideoPicture picture;
    483   ASSERT_EQ(PP_OK_COMPLETIONPENDING,
    484             CallGetPicture(decoder.get(), &picture, &get_picture_cb));
    485   SendPictureReady(params, 0U, kTextureId1);
    486   ASSERT_EQ(kTextureId1, picture.texture_id);
    487 
    488   CallRecyclePicture(decoder.get(), picture);
    489   uint32_t texture_id;
    490   ASSERT_TRUE(CheckRecyclePictureMsg(&params, &texture_id));
    491   ASSERT_EQ(kTextureId1, texture_id);
    492 
    493   ClearCallbacks(decoder.get());
    494 }
    495 #endif  // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
    496 
    497 TEST_F(VideoDecoderResourceTest, Flush) {
    498   LockingResourceReleaser decoder(CreateAndInitializeDecoder());
    499   ResourceMessageCallParams params, params2;
    500   MockCompletionCallback flush_cb, get_picture_cb, uncalled_cb;
    501 
    502   ASSERT_EQ(PP_OK_COMPLETIONPENDING, CallFlush(decoder.get(), &flush_cb));
    503   ASSERT_FALSE(flush_cb.called());
    504   ASSERT_TRUE(CheckFlushMsg(&params));
    505 
    506   ASSERT_EQ(PP_ERROR_FAILED, CallDecode(decoder.get(), &uncalled_cb, NULL));
    507   ASSERT_FALSE(uncalled_cb.called());
    508 
    509   // Plugin can call GetPicture while Flush is pending.
    510   ASSERT_EQ(PP_OK_COMPLETIONPENDING,
    511             CallGetPicture(decoder.get(), NULL, &get_picture_cb));
    512   ASSERT_FALSE(get_picture_cb.called());
    513 
    514   ASSERT_EQ(PP_ERROR_INPROGRESS, CallFlush(decoder.get(), &uncalled_cb));
    515   ASSERT_FALSE(uncalled_cb.called());
    516 
    517   ASSERT_EQ(PP_ERROR_FAILED, CallReset(decoder.get(), &uncalled_cb));
    518   ASSERT_FALSE(uncalled_cb.called());
    519 
    520   // Plugin can call RecyclePicture while Flush is pending.
    521   PP_VideoPicture picture;
    522   picture.texture_id = kTextureId1;
    523   CallRecyclePicture(decoder.get(), picture);
    524   uint32_t texture_id;
    525   ASSERT_TRUE(CheckRecyclePictureMsg(&params2, &texture_id));
    526 
    527   SendFlushReply(params);
    528   // Any pending GetPicture call is aborted.
    529   ASSERT_TRUE(get_picture_cb.called());
    530   ASSERT_EQ(PP_ERROR_ABORTED, get_picture_cb.result());
    531   ASSERT_TRUE(flush_cb.called());
    532   ASSERT_EQ(PP_OK, flush_cb.result());
    533 }
    534 
    535 // TODO(bbudge) Test Reset when we can run the message loop to get aborted
    536 // callbacks to run.
    537 
    538 // TODO(bbudge) Fix sync message testing on Windows 64 bit builds. The reply
    539 // message for GetShm isn't received, causing Decode to fail.
    540 // http://crbug.com/379260
    541 #if !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
    542 TEST_F(VideoDecoderResourceTest, NotifyError) {
    543   LockingResourceReleaser decoder(CreateAndInitializeDecoder());
    544   ResourceMessageCallParams params;
    545   MockCompletionCallback decode_cb, get_picture_cb, uncalled_cb;
    546 
    547   // Call Decode and GetPicture to have some pending requests.
    548   PpapiHostMsg_VideoDecoder_GetShm shm_msg(0U, kDecodeBufferSize);
    549   ASSERT_EQ(PP_OK, CallDecode(decoder.get(), &decode_cb, &shm_msg));
    550   ASSERT_FALSE(decode_cb.called());
    551   ASSERT_EQ(PP_OK_COMPLETIONPENDING,
    552             CallGetPicture(decoder.get(), NULL, &get_picture_cb));
    553   ASSERT_FALSE(get_picture_cb.called());
    554 
    555   // Send the decoder resource an unsolicited notify error message. We first
    556   // need to initialize 'params' so the message is routed to the decoder.
    557   uint32_t shm_id;
    558   uint32_t decode_size;
    559   int32_t decode_id;
    560   CheckDecodeMsg(&params, &shm_id, &decode_size, &decode_id);
    561   SendNotifyError(params, PP_ERROR_RESOURCE_FAILED);
    562 
    563   // Any pending message should be run with the reported error.
    564   ASSERT_TRUE(get_picture_cb.called());
    565   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED, get_picture_cb.result());
    566 
    567   // All further calls return the reported error.
    568   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED,
    569             CallDecode(decoder.get(), &uncalled_cb, NULL));
    570   ASSERT_FALSE(uncalled_cb.called());
    571   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED,
    572             CallGetPicture(decoder.get(), NULL, &uncalled_cb));
    573   ASSERT_FALSE(uncalled_cb.called());
    574   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED, CallFlush(decoder.get(), &uncalled_cb));
    575   ASSERT_FALSE(uncalled_cb.called());
    576   ASSERT_EQ(PP_ERROR_RESOURCE_FAILED, CallReset(decoder.get(), &uncalled_cb));
    577   ASSERT_FALSE(uncalled_cb.called());
    578 }
    579 #endif  // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
    580 
    581 }  // namespace proxy
    582 }  // namespace ppapi
    583