Avoid double task trampoline for Pipeline state transitions.

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 285 matching lines @@
       media_log_->CreateTimeEvent(
           MediaLogEvent::DURATION_SET, "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
   duration_ = duration;
   if (!duration_change_cb_.is_null())
     duration_change_cb_.Run();
 }
 
-void Pipeline::OnStateTransition(PipelineStatus status) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  // Force post to process state transitions after current execution frame.
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &Pipeline::StateTransitionTask, weak_factory_.GetWeakPtr(), status));
-}
-
 void Pipeline::StateTransitionTask(PipelineStatus status) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // No-op any state transitions if we're stopping.
   if (state_ == kStopping || state_ == kStopped)
     return;
 
   // Preserve existing abnormal status, otherwise update based on the result of
   // the previous operation.
   status_ = (status_ != PIPELINE_OK ? status_ : status);
 
   if (status_ != PIPELINE_OK) {
     ErrorChangedTask(status_);
     return;
   }
 
   // Guard against accidentally clearing |pending_callbacks_| for states that
   // use it as well as states that should not be using it.
   DCHECK_EQ(pending_callbacks_.get() != NULL, state_ == kSeeking);
 
   pending_callbacks_.reset();
 
   PipelineStatusCB done_cb =
-      base::Bind(&Pipeline::OnStateTransition, weak_factory_.GetWeakPtr());
+      base::Bind(&Pipeline::StateTransitionTask, weak_factory_.GetWeakPtr());
 
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
     case kInitRenderer:
       return InitializeRenderer(base::Bind(done_cb, PIPELINE_OK));
 
@@ skipping 253 matching lines @@
 
   const base::TimeDelta seek_timestamp =
       std::max(time, demuxer_->GetStartTime());
 
   SetState(kSeeking);
   seek_cb_ = seek_cb;
   renderer_ended_ = false;
   text_renderer_ended_ = false;
   start_timestamp_ = seek_timestamp;
 
-  DoSeek(seek_timestamp,
-         base::Bind(&Pipeline::OnStateTransition, weak_factory_.GetWeakPtr()));
+  DoSeek(seek_timestamp, base::Bind(&Pipeline::StateTransitionTask,
+                                    weak_factory_.GetWeakPtr()));
 }
 
 void Pipeline::SetCdmTask(CdmContext* cdm_context,
                           const CdmAttachedCB& cdm_attached_cb) {
   if (!renderer_) {
     pending_cdm_context_ = cdm_context;
     cdm_attached_cb.Run(true);
     return;
   }
 
@@ skipping 125 matching lines @@
   metadata_cb_.Run(metadata);
 }
 
 void Pipeline::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media