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