Move Pipeline permanent callbacks into Pipeline::Client interface.

media/filters/pipeline_controller.cc

 // Copyright 2016 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 "media/filters/pipeline_controller.h"
 
 #include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer.h"
 
 namespace media {
 
 PipelineController::PipelineController(
     Pipeline* pipeline,
     const RendererFactoryCB& renderer_factory_cb,
     const SeekedCB& seeked_cb,
     const SuspendedCB& suspended_cb,
     const PipelineStatusCB& error_cb)
     : pipeline_(pipeline),
       renderer_factory_cb_(renderer_factory_cb),
       seeked_cb_(seeked_cb),
       suspended_cb_(suspended_cb),
       error_cb_(error_cb),
       weak_factory_(this) {
   DCHECK(pipeline_);
   DCHECK(!renderer_factory_cb_.is_null());
   DCHECK(!seeked_cb_.is_null());
   DCHECK(!suspended_cb_.is_null());
   DCHECK(!error_cb_.is_null());
 }
 
 PipelineController::~PipelineController() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 // TODO(sandersd): If there is a pending suspend, don't call pipeline_.Start()
 // until Resume().
-void PipelineController::Start(
-    Demuxer* demuxer,
-    bool is_streaming,
-    bool is_static,
-    const base::Closure& ended_cb,
-    const PipelineMetadataCB& metadata_cb,
-    const BufferingStateCB& buffering_state_cb,
-    const base::Closure& duration_change_cb,
-    const AddTextTrackCB& add_text_track_cb,
-    const base::Closure& waiting_for_decryption_key_cb) {
+void PipelineController::Start(Demuxer* demuxer,
+                               Pipeline::Client* client,
+                               bool is_streaming,
+                               bool is_static) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == State::CREATED);
   DCHECK(demuxer);
 
   // Once the pipeline is started, we want to call the seeked callback but
   // without a time update.
   pending_seeked_cb_ = true;
   state_ = State::STARTING;
 
   demuxer_ = demuxer;
   is_streaming_ = is_streaming;
   is_static_ = is_static;
-  pipeline_->Start(
-      demuxer, renderer_factory_cb_.Run(), ended_cb,
-      BindToCurrentLoop(error_cb_),
-      BindToCurrentLoop(base::Bind(&PipelineController::OnPipelineStatus,
-                                   weak_factory_.GetWeakPtr(), State::PLAYING)),
-      metadata_cb, buffering_state_cb, duration_change_cb, add_text_track_cb,
-      waiting_for_decryption_key_cb);
+  pipeline_->Start(demuxer, renderer_factory_cb_.Run(), client,
+                   base::Bind(&PipelineController::OnPipelineStatus,
+                              weak_factory_.GetWeakPtr(), State::PLAYING));
 }
 
 void PipelineController::Seek(base::TimeDelta time, bool time_updated) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // It would be slightly more clear to set this in Dispatch(), but we want to
   // be sure it gets updated even if the seek is elided.
   if (time_updated)
     pending_time_updated_ = true;
   pending_seeked_cb_ = true;
@@ skipping 73 matching lines @@
 // Note: Dispatch() may be called re-entrantly (by callbacks internally) or
 // twice in a row (by OnPipelineStatus()).
 void PipelineController::Dispatch() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Suspend/resume transitions take priority because seeks before a suspend
   // are wasted, and seeks after can be merged into the resume operation.
   if (pending_suspend_ && state_ == State::PLAYING) {
     pending_suspend_ = false;
     state_ = State::SUSPENDING;
-    pipeline_->Suspend(BindToCurrentLoop(
-        base::Bind(&PipelineController::OnPipelineStatus,
-                   weak_factory_.GetWeakPtr(), State::SUSPENDED)));
+    pipeline_->Suspend(base::Bind(&PipelineController::OnPipelineStatus,
+                                  weak_factory_.GetWeakPtr(),
+                                  State::SUSPENDED));
     return;
   }
 
   if (pending_resume_ && state_ == State::SUSPENDED) {
     // If there is a pending seek, resume to that time instead...
     if (pending_seek_) {
       seek_time_ = pending_seek_time_;
       pending_seek_ = false;
     } else {
       seek_time_ = pipeline_->GetMediaTime();
@@ skipping 10 matching lines @@
     }
 
     // Tell |demuxer_| to expect our resume.
     DCHECK(!waiting_for_seek_);
     waiting_for_seek_ = true;
     demuxer_->StartWaitingForSeek(seek_time_);
 
     pending_resume_ = false;
     state_ = State::RESUMING;
     pipeline_->Resume(renderer_factory_cb_.Run(), seek_time_,
-                      BindToCurrentLoop(base::Bind(
-                          &PipelineController::OnPipelineStatus,
-                          weak_factory_.GetWeakPtr(), State::PLAYING)));
+                      base::Bind(&PipelineController::OnPipelineStatus,
+                                 weak_factory_.GetWeakPtr(), State::PLAYING));
     return;
   }
 
   // If we have pending operations, and a seek is ongoing, abort it.
   if ((pending_seek_ || pending_suspend_) && waiting_for_seek_) {
     // If there is no pending seek, return the current seek to pending status.
     if (!pending_seek_) {
       pending_seek_time_ = seek_time_;
       pending_seek_ = true;
     }
@@ skipping 10 matching lines @@
     seek_time_ = pending_seek_time_;
 
     // Tell |demuxer_| to expect our seek.
     DCHECK(!waiting_for_seek_);
     waiting_for_seek_ = true;
     demuxer_->StartWaitingForSeek(seek_time_);
 
     pending_seek_ = false;
     state_ = State::SEEKING;
     pipeline_->Seek(seek_time_,
-                    BindToCurrentLoop(base::Bind(
-                        &PipelineController::OnPipelineStatus,
-                        weak_factory_.GetWeakPtr(), State::PLAYING)));
+                    base::Bind(&PipelineController::OnPipelineStatus,
+                               weak_factory_.GetWeakPtr(), State::PLAYING));
     return;
   }
 
   // If |state_| is PLAYING and we didn't trigger an operation above then we
   // are in a stable state. If there is a seeked callback pending, emit it.
   if (state_ == State::PLAYING) {
     if (pending_seeked_cb_) {
       // |seeked_cb_| may be reentrant, so update state first and return
       // immediately.
       pending_seeked_cb_ = false;
       bool was_pending_time_updated = pending_time_updated_;
       pending_time_updated_ = false;
       seeked_cb_.Run(was_pending_time_updated);
       return;
     }
   }
 }
 
 }  // namespace media