Replace VideoRendererBase Get/PutCurrentFrame() with a VideoFrame-containing callback.

media/filters/video_renderer_base_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
@@ skipping 45 matching lines @@
     EXPECT_CALL(*demuxer_stream_, video_decoder_config())
         .WillRepeatedly(ReturnRef(video_config_));
 
     // We expect these to be called but we don't care how/when.
     EXPECT_CALL(*decoder_, Stop(_))
         .WillRepeatedly(RunClosure<0>());
     EXPECT_CALL(statistics_cb_object_, OnStatistics(_))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnTimeUpdate(_))
         .Times(AnyNumber());
-    EXPECT_CALL(*this, OnPaint())
-        .Times(AnyNumber());
     EXPECT_CALL(*this, OnSetOpaque(_))
         .Times(AnyNumber());
   }
 
   virtual ~VideoRendererBaseTest() {}
 
   // Callbacks passed into VideoRendererBase().
-  MOCK_CONST_METHOD0(OnPaint, void());
   MOCK_CONST_METHOD1(OnSetOpaque, void(bool));
 
   // Callbacks passed into Initialize().
   MOCK_METHOD1(OnTimeUpdate, void(base::TimeDelta));
   MOCK_METHOD1(OnNaturalSizeChanged, void(const gfx::Size&));
 
   void Initialize() {
     InitializeWithDuration(kVideoDurationInMs);
   }
 
@@ skipping 135 matching lines @@
     while (next_frame_timestamp_ < timestamp) {
       QueueNextFrame();
     }
 
     // Queue the frame at |timestamp| plus additional ones for prerolling.
     for (int i = 0; i < limits::kMaxVideoFrames; ++i) {
       QueueNextFrame();
     }
   }
 
+  void ResetCurrentFrame() {
+    base::AutoLock l(lock_);
+    current_frame_ = NULL;
+  }
+
   scoped_refptr<VideoFrame> GetCurrentFrame() {
-    scoped_refptr<VideoFrame> frame;
-    renderer_->GetCurrentFrame(&frame);
-    renderer_->PutCurrentFrame(frame);
-    return frame;
+    base::AutoLock l(lock_);
+    return current_frame_;
   }
 
   int GetCurrentTimestampInMs() {
     scoped_refptr<VideoFrame> frame = GetCurrentFrame();
     if (!frame)
       return -1;
     return frame->GetTimestamp().InMilliseconds();
   }
 
   void WaitForError(PipelineStatus expected) {
@@ skipping 52 matching lines @@
  private:
   base::TimeDelta GetTime() {
     base::AutoLock l(lock_);
     return time_;
   }
 
   base::TimeDelta GetDuration() {
     return duration_;
   }
 
+  void OnPaint(const scoped_refptr<VideoFrame>& frame) {
+    base::AutoLock l(lock_);
+    current_frame_ = frame;
+  }
+
   void FrameRequested(const VideoDecoder::ReadCB& read_cb) {
     DCHECK_EQ(&message_loop_, MessageLoop::current());
     CHECK(read_cb_.is_null());
     read_cb_ = read_cb;
 
     // Wake up WaitForPendingRead() if needed.
     if (!wait_for_pending_read_cb_.is_null())
       base::ResetAndReturn(&wait_for_pending_read_cb_).Run();
 
     if (decode_results_.empty())
@@ skipping 10 matching lines @@
       SatisfyPendingRead();
     }
 
     message_loop_.PostTask(FROM_HERE, callback);
   }
 
   MessageLoop message_loop_;
 
   VideoDecoderConfig video_config_;
 
-  // Used to protect |time_|.
+  // Used to protect |time_| and |current_frame_|.
   base::Lock lock_;
   base::TimeDelta time_;
+  scoped_refptr<VideoFrame> current_frame_;
 
   // Used for satisfying reads.
   VideoDecoder::ReadCB read_cb_;
   base::TimeDelta next_frame_timestamp_;
   base::TimeDelta duration_;
 
   WaitableMessageLoopEvent error_event_;
   WaitableMessageLoopEvent ended_event_;
 
   // Run during FrameRequested() to unblock WaitForPendingRead().
@@ skipping 130 matching lines @@
   Play();
   Pause();
   EXPECT_TRUE(GetCurrentFrame());
   Shutdown();
 }
 
 TEST_F(VideoRendererBaseTest, GetCurrentFrame_Flushed) {
   Initialize();
   Play();
   Pause();
+
+  // Frame shouldn't be updated.
+  ResetCurrentFrame();
   Flush();
   EXPECT_FALSE(GetCurrentFrame());
+
   Shutdown();
 }
 
 TEST_F(VideoRendererBaseTest, GetCurrentFrame_EndOfStream) {
   Initialize();
   Play();
   Pause();
   Flush();
 
   // Preroll only end of stream frames.
   QueueEndOfStream();
+
+  // Frame shouldn't be updated.
+  ResetCurrentFrame();
   Preroll(0, PIPELINE_OK);
   EXPECT_FALSE(GetCurrentFrame());
 
   // Start playing, we should immediately get notified of end of stream.
   Play();
   WaitForEnded();
 
   Shutdown();
 }
 
 TEST_F(VideoRendererBaseTest, GetCurrentFrame_Shutdown) {
   Initialize();
+
+  // Frame shouldn't be updated.
+  ResetCurrentFrame();
   Shutdown();
   EXPECT_FALSE(GetCurrentFrame());
 }
 
 // Stop() is called immediately during an error.
 TEST_F(VideoRendererBaseTest, GetCurrentFrame_Error) {
   Initialize();
+
+  // Frame shouldn't be updated.
+  ResetCurrentFrame();
   Stop();
   EXPECT_FALSE(GetCurrentFrame());
 }
 
-// Verify that shutdown can only proceed after we return the current frame.
-TEST_F(VideoRendererBaseTest, Shutdown_DuringPaint) {
-  Initialize();
-  Play();
-
-  // Grab the frame.
-  scoped_refptr<VideoFrame> frame;
-  renderer_->GetCurrentFrame(&frame);
-  EXPECT_TRUE(frame);
-
-  Pause();
-
-  // Start flushing -- it won't complete until we return the frame.
-  WaitableMessageLoopEvent event;
-  renderer_->Flush(event.GetClosure());
-
-  // Return the frame and wait.
-  renderer_->PutCurrentFrame(frame);
-  event.RunAndWait();
-
-  Stop();
-}
-
 // Verify that a late decoder response doesn't break invariants in the renderer.
 TEST_F(VideoRendererBaseTest, StopDuringOutstandingRead) {
   Initialize();
   Play();
 
   // Advance time a bit to trigger a Read().
   AdvanceTimeInMs(kFrameDurationInMs);
   WaitForPendingRead();
 
   WaitableMessageLoopEvent event;
@@ skipping 51 matching lines @@
   InSequence s;
 
   EXPECT_CALL(*decoder_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
   InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED);
 
   Stop();
 }
 
 }  // namespace media