Delete media::PipelineStatusNotification as it isn't used in production code.

The existing use in player_x11 is replaced by a base::WaitableEvent.

Review URL: https://codereview.chromium.org/14371024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@196778 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 24 insertions, 134 deletions

diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index bf93a9a..84a1e18 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -29,39 +29,6 @@ using base::TimeDelta;
 
 namespace media {
 
-PipelineStatusNotification::PipelineStatusNotification()
-    : cv_(&lock_), status_(PIPELINE_OK), notified_(false) {
-}
-
-PipelineStatusNotification::~PipelineStatusNotification() {
-  DCHECK(notified_);
-}
-
-PipelineStatusCB PipelineStatusNotification::Callback() {
-  return base::Bind(&PipelineStatusNotification::Notify,
-                    base::Unretained(this));
-}
-
-void PipelineStatusNotification::Notify(media::PipelineStatus status) {
-  base::AutoLock auto_lock(lock_);
-  DCHECK(!notified_);
-  notified_ = true;
-  status_ = status;
-  cv_.Signal();
-}
-
-void PipelineStatusNotification::Wait() {
-  base::AutoLock auto_lock(lock_);
-  while (!notified_)
-    cv_.Wait();
-}
-
-media::PipelineStatus PipelineStatusNotification::status() {
-  base::AutoLock auto_lock(lock_);
-  DCHECK(notified_);
-  return status_;
-}
-
 Pipeline::Pipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                    MediaLog* media_log)
     : message_loop_(message_loop),
diff --git a/media/base/pipeline.h b/media/base/pipeline.h
index 34e36f0..aa92269 100644
--- a/media/base/pipeline.h
+++ b/media/base/pipeline.h
@@ -32,33 +32,6 @@ class FilterCollection;
 class MediaLog;
 class VideoRenderer;
 
-// Adapter for using asynchronous Pipeline methods in code that wants to run
-// synchronously.  To use, construct an instance of this class and pass the
-// |Callback()| to the Pipeline method requiring a callback.  Then Wait() for
-// the callback to get fired and call status() to see what the callback's
-// argument was.  This object is for one-time use; call |Callback()| exactly
-// once.
-class MEDIA_EXPORT PipelineStatusNotification {
- public:
-  PipelineStatusNotification();
-  ~PipelineStatusNotification();
-
-  // See class-level comment for usage.
-  PipelineStatusCB Callback();
-  void Wait();
-  PipelineStatus status();
-
- private:
-  void Notify(media::PipelineStatus status);
-
-  base::Lock lock_;
-  base::ConditionVariable cv_;
-  media::PipelineStatus status_;
-  bool notified_;
-
-  DISALLOW_COPY_AND_ASSIGN(PipelineStatusNotification);
-};
-
 // Pipeline runs the media pipeline.  Filters are created and called on the
 // message loop injected into this object. Pipeline works like a state
 // machine to perform asynchronous initialization, pausing, seeking and playing.
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 9602e4a..ca0cc98 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -836,59 +836,6 @@ TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
   EXPECT_EQ(pipeline_->GetMediaTime(), new_time);
 }
 
-class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
- public:
-  FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,
-                         const PipelineStatusCB& status_cb)
-      : delay_(delay),
-        status_(status),
-        status_cb_(status_cb) {
-    if (delay_ < base::TimeDelta()) {
-      status_cb_.Run(status_);
-      return;
-    }
-  }
-  virtual void Run() OVERRIDE {
-    if (delay_ < base::TimeDelta()) return;
-    base::PlatformThread::Sleep(delay_);
-    status_cb_.Run(status_);
-  }
-
- private:
-  base::TimeDelta delay_;
-  PipelineStatus status_;
-  PipelineStatusCB status_cb_;
-};
-
-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));
-}
-
 class PipelineTeardownTest : public PipelineTest {
  public:
   enum TeardownState {
diff --git a/media/tools/player_x11/player_x11.cc b/media/tools/player_x11/player_x11.cc
index de45880..3a41d4a 100644
--- a/media/tools/player_x11/player_x11.cc
+++ b/media/tools/player_x11/player_x11.cc
@@ -100,8 +100,15 @@ static void NeedKey(const std::string& type, scoped_ptr<uint8[]> init_data,
   std::cout << "File is encrypted." << std::endl;
 }
 
+static void SaveStatusAndSignal(base::WaitableEvent* event,
+                                media::PipelineStatus* status_out,
+                                media::PipelineStatus status) {
+  *status_out = status;
+  event->Signal();
+}
+
 // TODO(vrk): Re-enabled audio. (crbug.com/112159)
-bool InitPipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
+void InitPipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                   media::Demuxer* demuxer,
                   const PaintCB& paint_cb,
                   bool /* enable_audio */,
@@ -133,23 +140,21 @@ bool InitPipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
   collection->SetAudioRenderer(audio_renderer.Pass());
 
   // Create the pipeline and start it.
+  base::WaitableEvent event(true, false);
+  media::PipelineStatus status;
+
   *pipeline = new media::Pipeline(message_loop, new media::MediaLog());
-  media::PipelineStatusNotification note;
   (*pipeline)->Start(
       collection.Pass(), base::Closure(), media::PipelineStatusCB(),
-      note.Callback(), base::Bind(&OnBufferingState), base::Closure());
+      base::Bind(&SaveStatusAndSignal, &event, &status),
+      base::Bind(&OnBufferingState), base::Closure());
 
   // Wait until the pipeline is fully initialized.
-  note.Wait();
-  if (note.status() != media::PIPELINE_OK) {
-    std::cout << "InitPipeline: " << note.status() << std::endl;
-    (*pipeline)->Stop(base::Closure());
-    return false;
-  }
+  event.Wait();
+  CHECK_EQ(status, media::PIPELINE_OK) << "Pipeline initialization failed";
 
   // And start the playback.
   (*pipeline)->SetPlaybackRate(1.0f);
-  return true;
 }
 
 void TerminateHandler(int signal) {
@@ -281,18 +286,16 @@ int main(int argc, char** argv) {
   scoped_ptr<media::Demuxer> demuxer(new media::FFmpegDemuxer(
       media_thread.message_loop_proxy(), data_source, base::Bind(&NeedKey)));
 
-  if (InitPipeline(media_thread.message_loop_proxy(), demuxer.get(),
-                   paint_cb, command_line->HasSwitch("audio"),
-                   &pipeline, &message_loop)) {
-    // Main loop of the application.
-    g_running = true;
+  InitPipeline(media_thread.message_loop_proxy(), demuxer.get(),
+               paint_cb, command_line->HasSwitch("audio"), &pipeline,
+               &message_loop);
 
-    message_loop.PostTask(FROM_HERE, base::Bind(
-        &PeriodicalUpdate, pipeline, &message_loop, !pipeline->HasVideo()));
-    message_loop.Run();
-  } else {
-    std::cout << "Pipeline initialization failed..." << std::endl;
-  }
+  // Main loop of the application.
+  g_running = true;
+
+  message_loop.PostTask(FROM_HERE, base::Bind(
+      &PeriodicalUpdate, pipeline, &message_loop, !pipeline->HasVideo()));
+  message_loop.Run();
 
   // Cleanup tasks.
   media_thread.Stop();