Merge 184048

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/debug/stack_trace.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/timer.h"
 #include "media/base/data_buffer.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/limits.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
@@ skipping 89 matching lines @@
     // We expect the video size to be set.
     EXPECT_CALL(*this, OnNaturalSizeChanged(kNaturalSize));
 
     // Start prerolling.
     QueuePrerollFrames(0);
     Preroll(0, PIPELINE_OK);
   }
 
   void InitializeRenderer(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("InitializeRenderer(%d)", expected));
+    WaitableMessageLoopEvent event;
+    CallInitialize(event.GetPipelineStatusCB());
+    event.RunAndWaitForStatus(expected);
+  }
+
+  void CallInitialize(const PipelineStatusCB& status_cb) {
     VideoRendererBase::VideoDecoderList decoders;
     decoders.push_back(decoder_);
-
-    WaitableMessageLoopEvent event;
     renderer_->Initialize(
         demuxer_stream_,
         decoders,
-        event.GetPipelineStatusCB(),
+        status_cb,
         base::Bind(&MockStatisticsCB::OnStatistics,
                    base::Unretained(&statistics_cb_object_)),
         base::Bind(&VideoRendererBaseTest::OnTimeUpdate,
                    base::Unretained(this)),
         base::Bind(&VideoRendererBaseTest::OnNaturalSizeChanged,
                    base::Unretained(this)),
         ended_event_.GetClosure(),
         error_event_.GetPipelineStatusCB(),
         base::Bind(&VideoRendererBaseTest::GetTime, base::Unretained(this)),
         base::Bind(&VideoRendererBaseTest::GetDuration,
                    base::Unretained(this)));
-    event.RunAndWaitForStatus(expected);
   }
 
   void Play() {
     SCOPED_TRACE("Play()");
     WaitableMessageLoopEvent event;
     renderer_->Play(event.GetClosure());
     event.RunAndWait();
   }
 
   void Preroll(int timestamp_ms, PipelineStatus expected) {
@@ skipping 200 matching lines @@
   WaitableMessageLoopEvent error_event_;
   WaitableMessageLoopEvent ended_event_;
   base::Closure pending_read_cb_;
 
   std::deque<std::pair<
       VideoDecoder::Status, scoped_refptr<VideoFrame> > > decode_results_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererBaseTest);
 };
 
+TEST_F(VideoRendererBaseTest, DoNothing) {
+  // Test that creation and deletion doesn't depend on calls to Initialize()
+  // and/or Stop().
+}
+
+TEST_F(VideoRendererBaseTest, StopWithoutInitialize) {
+  Stop();
+}
+
 TEST_F(VideoRendererBaseTest, Initialize) {
   Initialize();
   EXPECT_EQ(0, GetCurrentTimestampInMs());
   Shutdown();
 }
 
+static void ExpectNotCalled(PipelineStatus) {
+  base::debug::StackTrace stack;
+  ADD_FAILURE() << "Expected callback not to be called\n" << stack.ToString();
+}
+
+TEST_F(VideoRendererBaseTest, StopWhileInitializing) {
+  EXPECT_CALL(*decoder_, Initialize(_, _, _))
+      .WillOnce(RunCallback<1>(PIPELINE_OK));
+  CallInitialize(base::Bind(&ExpectNotCalled));
+  Stop();
+
+  // ~VideoRendererBase() will CHECK() if we left anything initialized.
+}
+
+TEST_F(VideoRendererBaseTest, StopWhileFlushing) {
+  Initialize();
+  Pause();
+  renderer_->Flush(base::Bind(&ExpectNotCalled, PIPELINE_OK));
+  Stop();
+
+  // ~VideoRendererBase() will CHECK() if we left anything initialized.
+}
+
 TEST_F(VideoRendererBaseTest, Play) {
   Initialize();
   Play();
   Shutdown();
 }
 
 TEST_F(VideoRendererBaseTest, EndOfStream_DefaultFrameDuration) {
   Initialize();
   Play();
 
@@ skipping 242 matching lines @@
   InSequence s;
 
   EXPECT_CALL(*decoder_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
   InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED);
 
   Stop();
 }
 
 }  // namespace media