Upgrade DCHECK(pending_callbacks_.get()) to CHECK().

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 406 matching lines @@
   TimeDelta epsilon = clock_->Duration() / 100;
   if (time_offset < epsilon)
     return TimeDelta();
   if (time_offset + epsilon > clock_->Duration())
     return clock_->Duration();
   return time_offset;
 }
 
 void Pipeline::DoPause(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(!pending_callbacks_.get());
+  CHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   if (audio_renderer_)
     bound_fns.Push(base::Bind(&AudioRenderer::Pause, audio_renderer_));
 
   if (video_renderer_)
     bound_fns.Push(base::Bind(&VideoRenderer::Pause, video_renderer_));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoFlush(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(!pending_callbacks_.get());
+  CHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   if (audio_renderer_)
     bound_fns.Push(base::Bind(&AudioRenderer::Flush, audio_renderer_));
 
   if (video_renderer_)
     bound_fns.Push(base::Bind(&VideoRenderer::Flush, video_renderer_));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoPlay(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(!pending_callbacks_.get());
+  CHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   if (audio_renderer_)
     bound_fns.Push(base::Bind(&AudioRenderer::Play, audio_renderer_));
 
   if (video_renderer_)
     bound_fns.Push(base::Bind(&VideoRenderer::Play, video_renderer_));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoStop(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(!pending_callbacks_.get());
+  CHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   if (demuxer_)
     bound_fns.Push(base::Bind(&Demuxer::Stop, demuxer_));
 
   if (audio_renderer_)
     bound_fns.Push(base::Bind(&AudioRenderer::Stop, audio_renderer_));
 
   if (video_renderer_)
     bound_fns.Push(base::Bind(&VideoRenderer::Stop, video_renderer_));
@@ skipping 390 matching lines @@
   demuxer_->OnAudioRendererDisabled();
 
   // Start clock since there is no more audio to
   // trigger clock updates.
   clock_->SetMaxTime(clock_->Duration());
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
 void Pipeline::FilterStateTransitionTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(pending_callbacks_.get())
+  CHECK(pending_callbacks_.get())
       << "Filter state transitions must be completed via pending_callbacks_";
   pending_callbacks_.reset();
 
   // State transitions while tearing down are handled via
   // TeardownStateTransitionTask().
   //
   // TODO(scherkus): Merge all state machinery!
   if (state_ == kStopped || tearing_down_) {
     return;
   }
@@ skipping 299 matching lines @@
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 void Pipeline::DoSeek(base::TimeDelta seek_timestamp,
                       bool skip_demuxer_seek,
                       const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(!pending_callbacks_.get());
+  CHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   if (!skip_demuxer_seek) {
     bound_fns.Push(base::Bind(
         &Demuxer::Seek, demuxer_, seek_timestamp));
   }
 
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Preroll, audio_renderer_, seek_timestamp));
@@ skipping 24 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media