MediaCodecLoop unit tests

media/base/android/media_codec_loop.h

 // Copyright 2016 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_BASE_ANDROID_MEDIA_CODEC_LOOP_H_
 #define MEDIA_BASE_ANDROID_MEDIA_CODEC_LOOP_H_
 
 #include <deque>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "media/base/android/media_codec_bridge.h"
-#include "media/base/audio_decoder.h"
-#include "media/base/audio_decoder_config.h"
+#include "media/base/decode_status.h"
 #include "media/base/media_export.h"
+#include "media/base/subsample_entry.h"
 
 // MediaCodecLoop is based on Android's MediaCodec API.
 // The MediaCodec API is required to play encrypted (as in EME) content on
 // Android. It is also a way to employ hardware-accelerated decoding.
 // One MediaCodecLoop instance owns a single MediaCodec(Bridge) instance, and
 // drives it to perform decoding in conjunction with a MediaCodecLoop::Client.
 // The Client provides the input data and consumes the output data.  A typical
 // example is AndroidVideoDecodeAccelerator.
 
 // Implementation notes.
@@ skipping 159 matching lines @@
 
     // Notify the client when our state transitions to STATE_ERROR.
     virtual void OnCodecLoopError() = 0;
 
    protected:
     virtual ~Client() {}
   };
 
   // We will take ownership of |media_codec|.  We will not destroy it until
   // we are destructed.  |media_codec| may not be null.
-  MediaCodecLoop(Client* client, std::unique_ptr<MediaCodecBridge> media_codec);
+  // |sdk_level| is temporary.  It is used only to decouple MediaCodecLoop from
+  // BuildInfo, until we get BuildInfo into a mockable state.
+  MediaCodecLoop(int sdk_level,
+                 Client* client,
+                 std::unique_ptr<MediaCodecBridge> media_codec,
+                 scoped_refptr<base::SingleThreadTaskRunner> =
+                     scoped_refptr<base::SingleThreadTaskRunner>());
   ~MediaCodecLoop();
 
+  // Optionally set the tick clock used for testing.  It is our caller's
+  // responsibility to maintain ownership of this, since
+  // FakeSingleThreadTaskRunner maintains a raw ptr to it also.
+  void SetTestTickClock(base::TickClock* test_tick_clock);
+
   // Does the MediaCodec processing cycle: enqueues an input buffer, then
   // dequeues output buffers.  This should be called by the client when more
   // work becomes available, such as when new input data arrives.  If codec
   // output buffers are freed after OnDecodedFrame returns, then this should
   // also be called.
   void DoPendingWork();
 
   // Try to flush this media codec.  Returns true on success, false on failure.
   // Failures can result in a state change to the Error state.  If this returns
   // false but the state is still READY, then the codec may continue to be used.
@@ skipping 51 matching lines @@
   // Returns true if an output buffer was received from MediaCodec.
   bool ProcessOneOutputBuffer();
 
   // Start the timer immediately if |start| is true or stop it based on elapsed
   // idle time if |start| is false.
   void ManageTimer(bool start);
 
   // Helper method to change the state.
   void SetState(State new_state);
 
+  // Helper method to tell us if MediaCodecBridge::Flush() doesn't work.
+  bool CodecNeedsFlushWorkaround() const;
+
   // A helper function for logging.
   static const char* AsString(State state);
 
-  // Used to post tasks. This class is single threaded and every method should
-  // run on this task runner.
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-
   State state_;
 
   // The client that we notify about MediaCodec events.
   Client* client_;
 
   // The MediaCodec instance that we're using.
   std::unique_ptr<MediaCodecBridge> media_codec_;
 
   // Repeating timer that kicks MediaCodec operation.
   base::RepeatingTimer io_timer_;
 
   // Time at which we last did useful work on |io_timer_|.
   base::TimeTicks idle_time_begin_;
 
   // Index of the dequeued and filled buffer that we keep trying to enqueue.
   // Such buffer appears in MEDIA_CODEC_NO_KEY processing. The -1 value means
   // there is no such buffer.
   int pending_input_buf_index_;
 
   // When processing a pending input buffer, this is the data that was returned
   // to us by the client.  |memory| has been cleared, since the codec has it.
   InputData pending_input_buf_data_;
 
+  // Optional clock for use during testing.  It may be null.  We do not maintain
+  // ownership of it.
+  base::TickClock* test_tick_clock_ = nullptr;
+
+  // BuildInfo::sdk_int(), eventually.
+  const int sdk_int_;
+
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaCodecLoop> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecLoop);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_CODEC_LOOP_H_