Remove delayed error posting from AndroidVideoDecodeAccelerator

media/gpu/android_video_decode_accelerator.h

 // Copyright (c) 2013 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.
 
 #ifndef MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 27 matching lines @@
 class SharedMemoryRegion;
 
 // A VideoDecodeAccelerator implementation for Android. This class decodes the
 // encded input stream using Android's MediaCodec. It handles the work of
 // transferring data to and from MediaCodec, and delegates attaching MediaCodec
 // output buffers to PictureBuffers to AVDAPictureBufferManager.
 class MEDIA_GPU_EXPORT AndroidVideoDecodeAccelerator
     : public VideoDecodeAccelerator,
       public AVDAStateProvider {
  public:
+  static VideoDecodeAccelerator::Capabilities GetCapabilities(
+      const gpu::GpuPreferences& gpu_preferences);
+
   AndroidVideoDecodeAccelerator(
       const MakeGLContextCurrentCallback& make_context_current_cb,
       const GetGLES2DecoderCallback& get_gles2_decoder_cb);
 
   ~AndroidVideoDecodeAccelerator() override;
 
   // VideoDecodeAccelerator implementation:
   bool Initialize(const Config& config, Client* client) override;
   void Decode(const BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(const std::vector<PictureBuffer>& buffers) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
   void SetSurface(int32_t surface_id) override;
   void Destroy() override;
   bool TryToSetupDecodeOnSeparateThread(
       const base::WeakPtr<Client>& decode_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner)
       override;
 
   // AVDAStateProvider implementation:
   const gfx::Size& GetSize() const override;
   base::WeakPtr<gpu::gles2::GLES2Decoder> GetGlDecoder() const override;
-  void PostError(const ::tracked_objects::Location& from_here,
-                 VideoDecodeAccelerator::Error error) override;
-
-  static VideoDecodeAccelerator::Capabilities GetCapabilities(
-      const gpu::GpuPreferences& gpu_preferences);
+  // Notifies the client about the error and sets |state_| to |ERROR|.
+  void NotifyError(Error error) override;
 
  private:
   friend class AVDAManager;
 
   // TODO(timav): evaluate the need for more states in the AVDA state machine.
   enum State {
     NO_ERROR,
     ERROR,
     // Set when we are asynchronously constructing the codec.  Will transition
     // to NO_ERROR or ERROR depending on success.
@@ skipping 137 matching lines @@
   // Notifies the client that the input buffer identifed by input_buffer_id has
   // been processed.
   void NotifyEndOfBitstreamBuffer(int input_buffer_id);
 
   // Notifies the client that the decoder was flushed.
   void NotifyFlushDone();
 
   // Notifies the client that the decoder was reset.
   void NotifyResetDone();
 
-  // Notifies about decoding errors.
-  // Note: you probably don't want to call this directly.  Use PostError or
-  // RETURN_ON_FAILURE, since we can defer error reporting to keep the pipeline
-  // from breaking.  NotifyError will do so immediately, PostError may wait.
-  // |token| has to match |error_sequence_token_|, or else it's assumed to be
-  // from a post that's prior to a previous reset, and ignored.
-  void NotifyError(VideoDecodeAccelerator::Error error, int token);
-
   // Start or stop our work-polling timer based on whether we did any work, and
   // how long it has been since we've done work.  Calling this with true will
   // start the timer.  Calling it with false may stop the timer.
   void ManageTimer(bool did_work);
 
   // Safely clear |media_codec_|.  Do this instead of calling reset() / assign.
   // Otherwise, the destructor can hang if mediaserver is in a bad state.  This
   // will release immediately if safe, else post to a separate thread.  Either
   // way, |media_codec_| will be null upon return.
   void ReleaseMediaCodec();
@@ skipping 117 matching lines @@
   scoped_refptr<CodecConfig> codec_config_;
 
   // Index of the dequeued and filled buffer that we keep trying to enqueue.
   // Such buffer appears in MEDIA_CODEC_NO_KEY processing.
   int pending_input_buf_index_;
 
   // Monotonically increasing value that is used to prevent old, delayed errors
   // from being sent after a reset.
   int error_sequence_token_;
 
-  // PostError will defer sending an error if and only if this is true.
-  bool defer_errors_;
-
   // True if and only if VDA initialization is deferred, and we have not yet
   // called NotifyInitializationComplete.
   bool deferred_initialization_pending_;
 
   // Indicates if ResetCodecState() should be called upon the next call to
   // Decode(). Allows us to avoid trashing the last few frames of a playback
   // when the EOS buffer is received.
   bool codec_needs_reset_;
 
   // True if surface creation and |picture_buffer_manager_| initialization has
@@ skipping 13 matching lines @@
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<AndroidVideoDecodeAccelerator> weak_this_factory_;
 
   friend class AndroidVideoDecodeAcceleratorTest;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_ANDROID_VIDEO_DECODE_ACCELERATOR_H_