media: Introduce Renderer interface and RendererImpl.

media/filters/video_renderer_impl.cc

 // Copyright 2013 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/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<VideoDecoder> decoders,
@@ skipping 94 matching lines @@
   DCHECK(!statistics_cb.is_null());
   DCHECK(!max_time_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!get_time_cb.is_null());
   DCHECK(!get_duration_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
 
   low_delay_ = low_delay;
 
-  init_cb_ = init_cb;
+  // Always post |init_cb_| because |this| could be destroyed if initialization
+  // failed.

[damienv1, 2014/08/06 16:10:03]

Could you please give me a callstack / sequence of events where this is an issue
?
This seems to me sth that should be handled by the owner of VideoRendererImpl
not by VideoRendererImpl itself.

[xhwang, 2014/08/07 05:46:49]

See:
https://codereview.chromium.org/418143005/diff/140001/media/filters/renderer_...

Basically in media code the callee should post instead of relying on the caller
to post. Maybe I should just make it an explicitly PostTask.

+  init_cb_ = BindToCurrentLoop(init_cb);
+
   statistics_cb_ = statistics_cb;
   max_time_cb_ = max_time_cb;
   buffering_state_cb_ = buffering_state_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   get_time_cb_ = get_time_cb;
   get_duration_cb_ = get_duration_cb;
   state_ = kInitializing;
 
   video_frame_stream_->Initialize(
@@ skipping 137 matching lines @@
   frames_decoded_++;
   frames_dropped_++;
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kFlushed);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
   if (status == VideoFrameStream::DECODE_ERROR ||
       status == VideoFrameStream::DECRYPT_ERROR) {
     DCHECK(!frame.get());
     PipelineStatus error = PIPELINE_ERROR_DECODE;
     if (status == VideoFrameStream::DECRYPT_ERROR)
       error = PIPELINE_ERROR_DECRYPT;
-    error_cb_.Run(error);
+    task_runner_->PostTask(FROM_HERE, base::Bind(error_cb_, error));
     return;
   }
 
   // Already-queued VideoFrameStream ReadCB's can fire after various state
   // transitions have happened; in that case just drop those frames immediately.
   if (state_ == kFlushing)
     return;
 
   DCHECK_EQ(state_, kPlaying);
 
@@ skipping 149 matching lines @@
     task_runner_->PostTask(FROM_HERE, base::Bind(statistics_cb_, statistics));
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media