Fix webrtc HW encode deadlock scenarios.

content/renderer/media/rtc_video_encoder.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_encoder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 232 matching lines @@
 void RTCVideoEncoder::Impl::Destroy() {
   DVLOG(3) << "Impl::Destroy()";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (video_encoder_)
     video_encoder_.release()->Destroy();
 }
 
 void RTCVideoEncoder::Impl::NotifyInitializeDone() {
   DVLOG(3) << "Impl::NotifyInitializeDone()";
   DCHECK(thread_checker_.CalledOnValidThread());
-  SignalAsyncWaiter(WEBRTC_VIDEO_CODEC_OK);
 }
 
 void RTCVideoEncoder::Impl::RequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) {
   DVLOG(3) << "Impl::RequireBitstreamBuffers(): input_count=" << input_count
            << ", input_coded_size=" << input_coded_size.ToString()
            << ", output_buffer_size=" << output_buffer_size;
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 27 matching lines @@
       return;
     }
     output_buffers_.push_back(shm);
   }
 
   // Immediately provide all output buffers to the VEA.
   for (size_t i = 0; i < output_buffers_.size(); ++i) {
     video_encoder_->UseOutputBitstreamBuffer(media::BitstreamBuffer(
         i, output_buffers_[i]->handle(), output_buffers_[i]->mapped_size()));
   }
+  SignalAsyncWaiter(WEBRTC_VIDEO_CODEC_OK);

[Ami GONE FROM CHROMIUM, 2013/09/03 20:09:54]

Nothing guarantees that RequireBB will be called until Encode() is called, which
won't happen until initialization is done.  The justification for this in the CL
description is insufficient.
If RequireBB was really part of VEA initialization, then NotifyInitializeDone
should not be triggered before RBB/UOBB were done.  

[Pawel Osciak, 2013/09/04 01:34:47]

Well, if you look at how this class does it right now, it silently assumes that
RequireBB has been finished before first Encode() is called on RTCVE.
RTCVE::Encode() gets into Impl::Enqueue() and if input_buffers_free is empty, it
doesn't call EncodeOneFrame(), just returns, so Encode() will wait forever. My
CL is an attempt to fix this as well.

[Ami GONE FROM CHROMIUM, 2013/09/04 20:47:56]

sheu@'s point about input_coded_size is reasonable to me.  I forgot that we let
that bleed into the API but it certainly guarantees RBB before first Encode. 
The diff in this file is fine by me now.

 }
 
 void RTCVideoEncoder::Impl::BitstreamBufferReady(int32 bitstream_buffer_id,
                                                  size_t payload_size,
                                                  bool key_frame) {
   DVLOG(3) << "Impl::BitstreamBufferReady(): "
               "bitstream_buffer_id=" << bitstream_buffer_id
            << ", payload_size=" << payload_size
            << ", key_frame=" << key_frame;
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 296 matching lines @@
 void RTCVideoEncoder::ReturnEncodedImage(scoped_ptr<webrtc::EncodedImage> image,
                                          int32 bitstream_buffer_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(3) << "ReturnEncodedImage(): "
               "bitstream_buffer_id=" << bitstream_buffer_id;
 
   if (!encoded_image_callback_)
     return;
 
   webrtc::CodecSpecificInfo info;
+  memset(&info, 0, sizeof(info));
   info.codecType = video_codec_type_;
 
   // Generate a header describing a single fragment.
   webrtc::RTPFragmentationHeader header;
+  memset(&header, 0, sizeof(header));
   header.VerifyAndAllocateFragmentationHeader(1);
   header.fragmentationOffset[0] = 0;
   header.fragmentationLength[0] = image->_length;
   header.fragmentationPlType[0] = 0;
   header.fragmentationTimeDiff[0] = 0;
 
   int32_t retval = encoded_image_callback_->Encoded(*image, &info, &header);
   if (retval < 0) {
     DVLOG(2) << "ReturnEncodedImage(): encoded_image_callback_ returned "
              << retval;
@@ skipping 12 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "NotifyError(): error=" << error;
 
   impl_status_ = error;
   gpu_factories_->GetMessageLoop()->PostTask(
       FROM_HERE, base::Bind(&RTCVideoEncoder::Impl::Destroy, impl_));
   impl_ = NULL;
 }
 
 }  // namespace content