Fix PipelineIntegrationTest so it can't hang on decoder errors.

media/filters/pipeline_integration_test.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/message_loop.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
 #include "media/base/message_loop_factory_impl.h"
 #include "media/base/pipeline.h"
@@ skipping 86 matching lines @@
 // in the real AudioRendererImpl & SkCanvasVideoRenderer implementations used in
 // the browser. The renderers in this test don't actually write data to a
 // display or audio device. Both of these devices are simulated since they have
 // little effect on verifying pipeline behavior and allow tests to run faster
 // than real-time.
 class PipelineIntegrationTest : public testing::Test {
  public:
   PipelineIntegrationTest()
       : message_loop_factory_(new MessageLoopFactoryImpl()),
         pipeline_(new Pipeline(&message_loop_, new MediaLog())),
-        ended_(false) {
+        ended_(false),
+        error_status_(PIPELINE_OK) {

[Ami GONE FROM CHROMIUM, 2012/01/31 19:06:54]

since it can hold OK, s/error_/pipeline_/

[acolwell GONE FROM CHROMIUM, 2012/01/31 19:16:00]

Done.

     EXPECT_CALL(*this, OnVideoRendererPaint()).Times(AnyNumber());
     EXPECT_CALL(*this, OnSetOpaque(true)).Times(AnyNumber());
   }
 
   virtual ~PipelineIntegrationTest() {
     if (!pipeline_->IsRunning())
       return;
 
     Stop();
   }
 
   void OnStatusCallback(PipelineStatus expected_status,
                         PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
+    error_status_ = status;
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   PipelineStatusCB QuitOnStatusCB(PipelineStatus expected_status) {
     return base::Bind(&PipelineIntegrationTest::OnStatusCallback,
                       base::Unretained(this),
                       expected_status);
   }
 
   void OnEnded(PipelineStatus status) {
     DCHECK_EQ(status, PIPELINE_OK);
     DCHECK(!ended_);
     ended_ = true;
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
-  void WaitUntilOnEnded() {
-    if (!ended_) {
-      message_loop_.Run();
-      DCHECK(ended_);
-    }
+  bool WaitUntilOnEnded() {
+    if (ended_)
+      return (error_status_ == PIPELINE_OK);
+    message_loop_.Run();
+    EXPECT_TRUE(ended_);
+    return ended_ && (error_status_ == PIPELINE_OK);
   }
 
-  MOCK_METHOD1(OnError, void(PipelineStatus));
+  void OnError(PipelineStatus status) {
+    DCHECK_NE(status, PIPELINE_OK);
+    error_status_ = status;
+    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
 
-  void Start(const std::string& url, PipelineStatus expected_status) {
+  bool Start(const std::string& url, PipelineStatus expected_status) {
     pipeline_->Start(
         CreateFilterCollection(url),
         url,
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         NetworkEventCB(),
         QuitOnStatusCB(expected_status));
     message_loop_.Run();
+    return (error_status_ == PIPELINE_OK);
   }
 
   void Play() {
     pipeline_->SetPlaybackRate(1);
   }
 
   void Pause() {
     pipeline_->SetPlaybackRate(0);
   }
 
-  void Seek(base::TimeDelta seek_time) {
+  bool Seek(base::TimeDelta seek_time) {
     ended_ = false;
 
     pipeline_->Seek(seek_time, QuitOnStatusCB(PIPELINE_OK));
     message_loop_.Run();
+    return (error_status_ == PIPELINE_OK);
   }
 
   void Stop() {
     DCHECK(pipeline_->IsRunning());
     pipeline_->Stop(QuitOnStatusCB(PIPELINE_OK));
     message_loop_.Run();
   }
 
   void QuitAfterCurrentTimeTask(const base::TimeDelta& quit_time) {
-    if (pipeline_->GetCurrentTime() >= quit_time) {
+    if (pipeline_->GetCurrentTime() >= quit_time ||
+        error_status_ != PIPELINE_OK) {
       message_loop_.Quit();
       return;
     }
 
     message_loop_.PostDelayedTask(
         FROM_HERE,
         base::Bind(&PipelineIntegrationTest::QuitAfterCurrentTimeTask,
                    base::Unretained(this), quit_time),
         10);
   }
 
-  void WaitUntilCurrentTimeIsAfter(const base::TimeDelta& wait_time) {
+  bool WaitUntilCurrentTimeIsAfter(const base::TimeDelta& wait_time) {
     DCHECK(pipeline_->IsRunning());
     DCHECK_GT(pipeline_->GetPlaybackRate(), 0);
     DCHECK(wait_time <= pipeline_->GetMediaDuration());
 
     message_loop_.PostDelayedTask(
         FROM_HERE,
         base::Bind(&PipelineIntegrationTest::QuitAfterCurrentTimeTask,
                    base::Unretained(this),
                    wait_time),
         10);
     message_loop_.Run();
+    return (error_status_ == PIPELINE_OK);
   }
 
   scoped_ptr<FilterCollection> CreateFilterCollection(const std::string& url) {
     scoped_refptr<FileDataSource> data_source = new FileDataSource();
     CHECK_EQ(PIPELINE_OK, data_source->Initialize(url));
     return CreateFilterCollection(scoped_ptr<DemuxerFactory>(
         new FFmpegDemuxerFactory(data_source, &message_loop_)));
   }
 
   scoped_ptr<FilterCollection> CreateFilterCollection(
@@ skipping 15 matching lines @@
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnSetOpaque,
                    base::Unretained(this))));
     collection->AddAudioRenderer(new NullAudioRenderer());
     return collection.Pass();
   }
 
   // Verifies that seeking works properly for ChunkDemuxer when the
   // seek happens while there is a pending read on the ChunkDemuxer
   // and no data is available.
-  void TestSeekDuringRead(const std::string& filename,
+  bool TestSeekDuringRead(const std::string& filename,
                           int initial_append_size,
                           base::TimeDelta start_seek_time,
                           base::TimeDelta seek_time,
                           int seek_file_position,
                           int seek_append_size) {
     MockMediaSource source(filename, initial_append_size);
 
     pipeline_->Start(CreateFilterCollection(&source), source.url(),
                      base::Bind(&PipelineIntegrationTest::OnEnded,
                                 base::Unretained(this)),
                      base::Bind(&PipelineIntegrationTest::OnError,
                                 base::Unretained(this)),
                      NetworkEventCB(),
                      QuitOnStatusCB(PIPELINE_OK));
     message_loop_.Run();
 
+    if (error_status_ != PIPELINE_OK)
+      return false;
+
     Play();
-    WaitUntilCurrentTimeIsAfter(start_seek_time);
+    if (!WaitUntilCurrentTimeIsAfter(start_seek_time))
+      return false;
 
     source.Seek(seek_file_position, seek_append_size);
-    Seek(seek_time);
+    if (!Seek(seek_time))
+      return false;
 
     source.EndOfStream();
 
     source.Abort();
     Stop();
+    return true;
   }
 
  protected:
   MessageLoop message_loop_;
   scoped_ptr<MessageLoopFactory> message_loop_factory_;
   scoped_refptr<Pipeline> pipeline_;
   bool ended_;
+  PipelineStatus error_status_;
 
  private:
   MOCK_METHOD0(OnVideoRendererPaint, void());
   MOCK_METHOD1(OnSetOpaque, void(bool));
 };
 
 
 TEST_F(PipelineIntegrationTest, BasicPlayback) {
-  Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK);
+  ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK));
 
   Play();
 
-  WaitUntilOnEnded();
+  ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 TEST_F(PipelineIntegrationTest, SeekWhilePaused) {
-  Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK);
+  ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
-  WaitUntilCurrentTimeIsAfter(start_seek_time);
+  ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
   Pause();
-  Seek(seek_time);
+  ASSERT_TRUE(Seek(seek_time));
   EXPECT_EQ(pipeline_->GetCurrentTime(), seek_time);
   Play();
-  WaitUntilOnEnded();
+  ASSERT_TRUE(WaitUntilOnEnded());
 
   // Make sure seeking after reaching the end works as expected.
   Pause();
-  Seek(seek_time);
+  ASSERT_TRUE(Seek(seek_time));
   EXPECT_EQ(pipeline_->GetCurrentTime(), seek_time);
   Play();
-  WaitUntilOnEnded();
+  ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // TODO(acolwell): Fix flakiness http://crbug.com/109875
-TEST_F(PipelineIntegrationTest, DISABLED_SeekWhilePlaying) {
-  Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK);
+TEST_F(PipelineIntegrationTest, FLAKY_SeekWhilePlaying) {
+  ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
-  WaitUntilCurrentTimeIsAfter(start_seek_time);
-  Seek(seek_time);
+  ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
+  ASSERT_TRUE(Seek(seek_time));
   EXPECT_GE(pipeline_->GetCurrentTime(), seek_time);
-  WaitUntilOnEnded();
+  ASSERT_TRUE(WaitUntilOnEnded());
 
   // Make sure seeking after reaching the end works as expected.
-  Seek(seek_time);
+  ASSERT_TRUE(Seek(seek_time));
   EXPECT_GE(pipeline_->GetCurrentTime(), seek_time);
-  WaitUntilOnEnded();
+  ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // Verify audio decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
-  TestSeekDuringRead("bear-320x240-audio-only.webm", 8192,
-                     base::TimeDelta::FromMilliseconds(477),
-                     base::TimeDelta::FromMilliseconds(617),
-                     0x10CA, 19730);
+  ASSERT_TRUE(TestSeekDuringRead("bear-320x240-audio-only.webm", 8192,
+                                 base::TimeDelta::FromMilliseconds(477),
+                                 base::TimeDelta::FromMilliseconds(617),
+                                 0x10CA, 19730));
 }
 
 // Verify video decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
-  TestSeekDuringRead("bear-320x240-video-only.webm", 32768,
-                     base::TimeDelta::FromMilliseconds(200),
-                     base::TimeDelta::FromMilliseconds(1668),
-                     0x1C896, 65536);
+  ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", 32768,
+                                 base::TimeDelta::FromMilliseconds(200),
+                                 base::TimeDelta::FromMilliseconds(1668),
+                                 0x1C896, 65536));
 }
 
 }  // namespace media