To dropp the decode done callback in RTCVideoDecoderBridgeTv.

content/renderer/media/rtc_video_decoder_bridge_tv.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 "content/renderer/media/rtc_video_decoder_bridge_tv.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/time/time.h"
 #include "content/renderer/media/rtc_video_decoder_factory_tv.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "third_party/libjingle/source/talk/base/ratetracker.h"
 
 namespace content {
 
 RTCVideoDecoderBridgeTv::RTCVideoDecoderBridgeTv(
     RTCVideoDecoderFactoryTv* factory)
     : factory_(factory),
       is_initialized_(false),
-      first_frame_(true),
-      decode_complete_callback_(NULL) {}
+      first_frame_(true) {}
 
 RTCVideoDecoderBridgeTv::~RTCVideoDecoderBridgeTv() {}
 
 int32_t RTCVideoDecoderBridgeTv::InitDecode(
     const webrtc::VideoCodec* codec_settings,
     int32_t number_of_cores) {
   // We don't support non-VP8 codec, feedback mode, nor double-initialization
   if (codec_settings->codecType != webrtc::kVideoCodecVP8 ||
       codec_settings->codecSpecific.VP8.feedbackModeOn || is_initialized_)
     return WEBRTC_VIDEO_CODEC_ERROR;
@@ skipping 10 matching lines @@
     const webrtc::EncodedImage& input_image,
     bool missing_frames,
     const webrtc::RTPFragmentationHeader* fragmentation,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     int64_t render_time_ms) {
   // Unlike the SW decoder in libvpx, hw decoder can not handle broken frames.
   // Here, we return an error in order to request a key frame.
   if (missing_frames || !input_image._completeFrame)
     return WEBRTC_VIDEO_CODEC_ERROR;
 
-  if (!is_initialized_ || decode_complete_callback_ == NULL)
+  if (!is_initialized_)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
   if (first_frame_) {
     // If the first frame is not a key frame, return an error to request a key
     // frame.
     if (input_image._frameType != webrtc::kKeyFrame)
       return WEBRTC_VIDEO_CODEC_ERROR;
 
     // Google TV expects timestamp from 0, so we store the initial timestamp as
     // an offset and subtract the value from every timestamps to meet the
@@ skipping 13 matching lines @@
   }
   // |input_image_| may be destroyed after this call, so we make a copy of the
   // buffer so that we can queue the buffer asynchronously.
   scoped_refptr<media::DecoderBuffer> buffer =
       media::DecoderBuffer::CopyFrom(input_image._buffer, input_image._length);
   if (render_time_ms != -1) {
     buffer->set_timestamp(base::TimeDelta::FromMilliseconds(
         render_time_ms - timestamp_offset_millis_));
   }
 
-  factory_->QueueBuffer(
-      buffer,
-      base::Bind(&RTCVideoDecoderBridgeTv::RunDecodeCompleteCallback,
-                 decode_complete_callback_,
-                 input_image._timeStamp,
-                 size_),
-      new_size);
+  factory_->QueueBuffer(buffer, new_size);
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoderBridgeTv::RegisterDecodeCompleteCallback(
     webrtc::DecodedImageCallback* callback) {
-  decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoderBridgeTv::Release() {
   is_initialized_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoderBridgeTv::Reset() {
   first_frame_ = true;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-// static
-void RTCVideoDecoderBridgeTv::RunDecodeCompleteCallback(
-    webrtc::DecodedImageCallback* callback,
-    int64_t timestamp,
-    gfx::Size size) {
-  // We call the decode complete callback function to notify libjingle that
-  // decoding is finished. In addition, this also reports back to libjingle that
-  // the particular video frame with |timestamp| is correctly rendered to
-  // libjingle, so that it can generate proper stats.
-  webrtc::I420VideoFrame dummy_video_frame;
-  int half_width = (size.width() + 1) / 2;
-  dummy_video_frame.CreateEmptyFrame(
-      size.width(), size.height(), size.width(), half_width, half_width);
-  dummy_video_frame.set_timestamp(timestamp);
-  callback->Decoded(dummy_video_frame);
-}
-
 }  // namespace content