PipelineError is dead. Long live PipelineStatus!

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/callback.h"
 #include "base/stl_util-inl.h"
+#include "base/threading/simple_thread.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
@@ skipping 13 matching lines @@
 // Buffered bytes of the data source.
 static const int kBufferedBytes = 1024;
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
-  MOCK_METHOD0(OnStart, void());
-  MOCK_METHOD0(OnSeek, void());
-  MOCK_METHOD0(OnStop, void());
-  MOCK_METHOD0(OnEnded, void());
-  MOCK_METHOD0(OnError, void());
+  MOCK_METHOD1(OnStart, void(PipelineStatus));
+  MOCK_METHOD1(OnSeek, void(PipelineStatus));
+  MOCK_METHOD1(OnStop, void(PipelineStatus));
+  MOCK_METHOD1(OnEnded, void(PipelineStatus));
+  MOCK_METHOD1(OnError, void(PipelineStatus));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
 // initialization is moved to a separate thread this test will become flaky.
 class PipelineImplTest : public ::testing::Test {
  public:
   PipelineImplTest()
       : pipeline_(new PipelineImpl(&message_loop_)) {
     pipeline_->Init(
         NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                     &CallbackHelper::OnEnded),
         NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                     &CallbackHelper::OnError),
-        NULL);
+        static_cast<PipelineStatusCallback*>(NULL));
     mocks_.reset(new MockFilterCollection());
   }
 
   virtual ~PipelineImplTest() {
     if (!pipeline_->IsRunning()) {
       return;
     }
 
     // Expect a stop callback if we were started.
-    EXPECT_CALL(callbacks_, OnStop());
+    EXPECT_CALL(callbacks_, OnStop(PIPELINE_OK));
     pipeline_->Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                 &CallbackHelper::OnStop));
     message_loop_.RunAllPending();
 
     mocks_.reset();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
@@ skipping 80 matching lines @@
     EXPECT_CALL(*mocks_->audio_renderer(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline() {
     InitializePipeline(PIPELINE_OK);
   }
 
-  void InitializePipeline(PipelineError factory_error) {
+  void InitializePipeline(PipelineStatus start_status) {
     // Expect an initialization callback.
-    EXPECT_CALL(callbacks_, OnStart());
-    pipeline_->Start(mocks_->filter_collection(true, true, factory_error),
-                     "",
+    EXPECT_CALL(callbacks_, OnStart(start_status));
+    pipeline_->Start(mocks_->filter_collection(), "",
                      NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                  &CallbackHelper::OnStart));
     message_loop_.RunAllPending();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
@@ skipping 21 matching lines @@
     }
 
     if (video_stream_) {
       EXPECT_CALL(*mocks_->video_decoder(), Seek(seek_time, NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
       EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
     }
 
     // We expect a successful seek callback.
-    EXPECT_CALL(callbacks_, OnSeek());
+    EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
 
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
                     NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                 &CallbackHelper::OnSeek));
 
     // We expect the time to be updated only after the seek has completed.
     EXPECT_NE(seek_time, pipeline_->GetCurrentTime());
@@ skipping 51 matching lines @@
 
   EXPECT_EQ(0, pipeline_->GetBufferedBytes());
   EXPECT_EQ(0, pipeline_->GetTotalBytes());
 
   // Should always get set to zero.
   size_t width = 1u;
   size_t height = 1u;
   pipeline_->GetVideoSize(&width, &height);
   EXPECT_EQ(0u, width);
   EXPECT_EQ(0u, height);
-
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 }
 
 TEST_F(PipelineImplTest, NeverInitializes) {
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(mocks_->filter_collection(false, false, PIPELINE_OK), "",
                    NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                &CallbackHelper::OnStart));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
-  EXPECT_CALL(callbacks_, OnStart());
+  EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineImplTest, RequiredFilterMissing) {
-  EXPECT_CALL(callbacks_, OnError());
+  EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   // Expect an initialization callback.
-  EXPECT_CALL(callbacks_, OnStart());
+  EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
 
   // Create a filter collection with missing filter.
   FilterCollection* collection =
       mocks_->filter_collection(false, true,
                                 PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
   pipeline_->Start(collection, "",
                    NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                &CallbackHelper::OnStart));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_ERROR_REQUIRED_FILTER_MISSING,
-            pipeline_->GetError());
-}
-
-TEST_F(PipelineImplTest, URLNotFound) {

[acolwell GONE FROM CHROMIUM, 2011/03/15 03:56:28]

Was this test delete by accident?

[Ami GONE FROM CHROMIUM, 2011/03/15 17:37:18]

Apparently so.

-
-  EXPECT_CALL(callbacks_, OnError());
-
-  InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
-  EXPECT_FALSE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_ERROR_URL_NOT_FOUND, pipeline_->GetError());
 }
 
 TEST_F(PipelineImplTest, NoStreams) {
   // Manually set these expectations because SetPlaybackRate() is not called if
   // we cannot fully initialize the pipeline.
   EXPECT_CALL(*mocks_->demuxer(), GetNumberOfStreams())
       .WillRepeatedly(Return(0));
   EXPECT_CALL(*mocks_->demuxer(), Stop(NotNull()))
       .WillOnce(Invoke(&RunStopFilterCallback));
-  EXPECT_CALL(callbacks_, OnError());
+  EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_COULD_NOT_RENDER));
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
   EXPECT_FALSE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_ERROR_COULD_NOT_RENDER, pipeline_->GetError());
 }
 
 TEST_F(PipelineImplTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_FALSE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineImplTest, VideoStream) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineImplTest, AudioVideoStream) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineImplTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   ExpectSeek(expected);
 
   // Initialize then seek!
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   DoSeek(expected);
 }
 
 TEST_F(PipelineImplTest, SetVolume) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(expected));
 
   // Initialize then set volume!
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   pipeline_->SetVolume(expected);
 }
 
 TEST_F(PipelineImplTest, Properties) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetMediaDuration().ToInternalValue());
   EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
   EXPECT_EQ(kBufferedBytes, pipeline_->GetBufferedBytes());
 
   // Because kTotalBytes and kBufferedBytes are equal to each other,
   // the entire video should be buffered.
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetBufferedTime().ToInternalValue());
 }
 
 TEST_F(PipelineImplTest, GetBufferedTime) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // TODO(vrk): The following mini-test cases are order-dependent, and should
   // probably be separated into independent test cases.
 
   // Buffered time is 0 if no bytes are buffered.
   pipeline_->SetBufferedBytes(0);
   EXPECT_EQ(0, pipeline_->GetBufferedTime().ToInternalValue());
 
   // We should return buffered_time_ if it is set, valid and less than
   // the current time.
@@ skipping 47 matching lines @@
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(1.0f))
       .WillOnce(DisableAudioRenderer(mocks_->audio_renderer()));
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_renderer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_renderer(),
               OnAudioRendererDisabled());
 
   mocks_->audio_renderer()->SetPlaybackRate(1.0f);
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
-  EXPECT_CALL(callbacks_, OnEnded());
+  EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   FilterHost* host = pipeline_;
   host->NotifyEnded();
 }
 
 TEST_F(PipelineImplTest, DisableAudioRendererDuringInit) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer(true);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->audio_renderer(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_decoder(),
               OnAudioRendererDisabled());
   EXPECT_CALL(*mocks_->video_renderer(),
               OnAudioRendererDisabled());
 
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
   EXPECT_TRUE(pipeline_->IsInitialized());
-  EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
-  EXPECT_CALL(callbacks_, OnEnded());
+  EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   FilterHost* host = pipeline_;
   host->NotifyEnded();
 }
 
 TEST_F(PipelineImplTest, EndedCallback) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
 
   // For convenience to simulate filters calling the methods.
   FilterHost* host = pipeline_;
 
   // Due to short circuit evaluation we only need to test a subset of cases.
   InSequence s;
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(false));
   host->NotifyEnded();
 
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(false));
   host->NotifyEnded();
 
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
-  EXPECT_CALL(callbacks_, OnEnded());
+  EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   host->NotifyEnded();
 }
 
 // Static function & time variable used to simulate changes in wallclock time.
 static int64 g_static_clock_time;
 static base::Time StaticClockFunction() {
   return base::Time::FromInternalValue(g_static_clock_time);
 }
 
 TEST_F(PipelineImplTest, AudioStreamShorterThanVideo) {
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, duration);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
 
   // For convenience to simulate filters calling the methods.
   FilterHost* host = pipeline_;
 
   // Replace the clock so we can simulate wallclock time advancing w/o using
   // Sleep().
   pipeline_->SetClockForTesting(new Clock(&StaticClockFunction));
 
   EXPECT_EQ(0, host->GetTime().ToInternalValue());
 
@@ skipping 27 matching lines @@
   start_time = host->GetTime().ToInternalValue();
   g_static_clock_time +=
       base::TimeDelta::FromMilliseconds(100).ToInternalValue();
   EXPECT_GT(host->GetTime().ToInternalValue(), start_time);
 
   // Signal end of video stream and make sure OnEnded() callback occurs.
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
-  EXPECT_CALL(callbacks_, OnEnded());
+  EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   host->NotifyEnded();
 }
 
 TEST_F(PipelineImplTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
-  InitializePipeline();
+  InitializePipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_decoder(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   InSequence s;
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, NotNull()))
       .WillOnce(DoAll(SetError(mocks_->demuxer(),
                                PIPELINE_ERROR_READ),
                       Invoke(&RunFilterCallback)));
 
-  pipeline_->Seek(seek_time, NewExpectedCallback());
-  EXPECT_CALL(callbacks_, OnError());
+  pipeline_->Seek(seek_time, NewCallback(
+      reinterpret_cast<CallbackHelper*>(&callbacks_), &CallbackHelper::OnSeek));
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+  EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
+class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
+ public:
+  FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,

[acolwell GONE FROM CHROMIUM, 2011/03/15 03:56:28]

How about just an int called delayInMs? It would remove the conversion to and
from TimeDelta

[Ami GONE FROM CHROMIUM, 2011/03/15 17:37:18]

Nice catch.

+                         PipelineStatusCallback* callback)
+      : delay_(delay), status_(status), callback_(callback) {
+    if (delay_.InMilliseconds() < 0) {
+      callback_->Run(status_);
+      return;
+    }
+  }
+  virtual void Run() {
+    if (delay_.InMilliseconds() < 0) return;
+    base::PlatformThread::Sleep(static_cast<int>(delay_.InMilliseconds()));
+    callback_->Run(status_);
+  }
+
+ private:
+  base::TimeDelta delay_;
+  PipelineStatus status_;
+  PipelineStatusCallback* callback_;
+};
+
+void TestPipelineStatusNotification(base::TimeDelta delay) {
+  PipelineStatusNotification note;
+  // Arbitrary error value we expect to fish out of the notification after the
+  // callback is fired.
+  const PipelineStatus expected_error = PIPELINE_ERROR_URL_NOT_FOUND;
+  FlexibleCallbackRunner runner(delay, expected_error, note.Callback());
+  base::DelegateSimpleThread thread(&runner, "FlexibleCallbackRunner");
+  thread.Start();
+  note.Wait();
+  EXPECT_EQ(note.status(), expected_error);
+  thread.Join();
+}
+
+// Test that in-line callback (same thread, no yield) works correctly.
+TEST(PipelineStatusNotificationTest, InlineCallback) {
+  TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(-1));
+}
+
+// Test that different-thread, no-delay callback works correctly.
+TEST(PipelineStatusNotificationTest, ImmediateCallback) {
+  TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(0));
+}
+
+// Test that different-thread, some-delay callback (the expected common case)
+// works correctly.
+TEST(PipelineStatusNotificationTest, DelayedCallback) {
+  TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
+}
+
 }  // namespace media