Report media error if PlayOutputBuffer failed

media/base/android/video_media_codec_decoder.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 "media/base/android/video_media_codec_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 203 matching lines @@
   // correspond to the actual video frame size, but this is not necessarily the
   // size that should be output.
   video_size_ = configs_.video_size;
   if (video_size_ != prev_size) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(video_size_changed_cb_, video_size_));
   }
   return true;
 }
 
-void VideoMediaCodecDecoder::Render(int buffer_index,
+bool VideoMediaCodecDecoder::Render(int buffer_index,
                                     size_t offset,
                                     size_t size,
                                     RenderMode render_mode,
                                     base::TimeDelta pts,
                                     bool eos_encountered) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
            << (eos_encountered ? " EOS " : " ") << AsString(render_mode);
 
@@ skipping 11 matching lines @@
 
   // Do not update time for stand-alone EOS.
   const bool update_time = !(eos_encountered && size == 0u);
 
   // For video we simplify the preroll operation and render the first frame
   // after preroll during the preroll phase, i.e. without waiting for audio
   // stream to finish prerolling.
   switch (render_mode) {
     case kRenderSkip:
       ReleaseOutputBuffer(buffer_index, pts, false, false, eos_encountered);
-      return;
+      return true;
     case kRenderAfterPreroll:
       // We get here in the preroll phase. Render now as explained above.
       // |start_pts_| is not set yet, thus we cannot calculate |time_to_render|.
       ReleaseOutputBuffer(buffer_index, pts, (size > 0), update_time,
                           eos_encountered);
-      return;
+      return true;
     case kRenderNow:
       break;
   }
 
   DCHECK_EQ(kRenderNow, render_mode);
   DCHECK_NE(kNoTimestamp(), start_pts_);  // start_pts_ must be set
 
   base::TimeDelta time_to_render =
       pts - (base::TimeTicks::Now() - start_time_ticks_ + start_pts_);
 
@@ skipping 10 matching lines @@
     if (render) {
       DVLOG(2) << class_name() << "::" << __FUNCTION__
                << " LATE FRAME delay:" << (-1) * time_to_render;
 
       frame_statistics_->IncrementLateFrameCount();
     }
 
     // Render late frames immediately.
     ReleaseOutputBuffer(buffer_index, pts, render, update_time,
                         eos_encountered);
-    return;
+    return true;
   }
 
   delayed_buffers_.insert(buffer_index);
 
   decoder_thread_.task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&VideoMediaCodecDecoder::ReleaseOutputBuffer,
                             base::Unretained(this), buffer_index, pts, render,
                             update_time, eos_encountered),
       time_to_render);
+
+  return true;
 }
 
 int VideoMediaCodecDecoder::NumDelayedRenderTasks() const {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   return delayed_buffers_.size();
 }
 
 void VideoMediaCodecDecoder::ReleaseDelayedBuffers() {
   // Media thread
@@ skipping 35 matching lines @@
 
   // |update_current_time_cb_| might be null if there is audio stream.
   // Do not update current time for stand-alone EOS frames.
   if (!update_current_time_cb_.is_null() && update_time) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(update_current_time_cb_, pts, pts, false));
   }
 }
 
 }  // namespace media