Convert WMPI state management to level-triggered.

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 ResumedCB& resumed_cb,
     const PipelineStatusCB& error_cb)
     : pipeline_(pipeline),
       renderer_factory_cb_(renderer_factory_cb),
       seeked_cb_(seeked_cb),
       suspended_cb_(suspended_cb),
-      resumed_cb_(resumed_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(!resumed_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(
@@ skipping 64 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   pending_suspend_ = false;
   if (state_ == State::SUSPENDING || state_ == State::SUSPENDED) {
     pending_resume_ = true;
     Dispatch();
   }
 }
 
 bool PipelineController::IsStable() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return (state_ == State::PLAYING);
+  return state_ == State::PLAYING;
 }
 
 bool PipelineController::IsSuspended() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return (state_ == State::SUSPENDED);
+  return (pending_suspend_ || state_ == State::SUSPENDED) && !pending_resume_;
+}
+
+bool PipelineController::IsPipelineSuspended() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return state_ == State::SUSPENDED;
 }
 
 void PipelineController::OnPipelineStatus(State state,
                                           PipelineStatus pipeline_status) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (pipeline_status != PIPELINE_OK) {
     error_cb_.Run(pipeline_status);
     return;
   }
 
   state_ = state;
 
   if (state == State::PLAYING) {
     // Start(), Seek(), or Resume() completed; we can be sure that
     // |demuxer_| got the seek it was waiting for.
     waiting_for_seek_ = false;
-    if (pending_resumed_cb_) {
-      pending_resumed_cb_ = false;
-
-      // Warning: possibly reentrant. The state may change inside this callback.
-      // It must be safe to call Dispatch() twice in a row here.
-      resumed_cb_.Run();
-    }
   } else if (state == State::SUSPENDED) {
-    pending_resumed_cb_ = true;
-
     // Warning: possibly reentrant. The state may change inside this callback.
     // It must be safe to call Dispatch() twice in a row here.
     suspended_cb_.Run();
   }
 
   Dispatch();
 }
 
 // Note: Dispatch() may be called re-entrantly (by callbacks internally) or
 // twice in a row (by OnPipelineStatus()).
@@ skipping 86 matching lines @@
       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