Resolve media/cast crypto crash, and add crash reporting.

media/cast/sender/vp8_encoder.cc

 // Copyright 2014 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/cast/sender/vp8_encoder.h"
 
+#include "base/debug/crash_logging.h"
+#include "base/debug/dump_without_crashing.h"
+#include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/strings/stringprintf.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
 #include "third_party/libvpx_new/source/libvpx/vpx/vp8cx.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // After a pause in the video stream, what is the maximum duration amount to
 // pass to the encoder for the next frame (in terms of 1/max_fps sized periods)?
 // This essentially controls the encoded size of the first frame that follows a
 // pause in the video stream.
 const int kRestartFramePeriods = 3;
 
 }  // namespace
 
 Vp8Encoder::Vp8Encoder(const VideoSenderConfig& video_config)
     : cast_config_(video_config),
       use_multiple_video_buffers_(
           cast_config_.max_number_of_video_buffers_used ==
           kNumberOfVp8VideoBuffers),
       key_frame_requested_(true),
       bitrate_kbit_(cast_config_.start_bitrate / 1000),
       last_encoded_frame_id_(kStartFrameId),
       last_acked_frame_id_(kStartFrameId),
-      undroppable_frames_(0) {
+      undroppable_frames_(0),
+      has_seen_zero_length_encoded_frame_(false) {
   config_.g_timebase.den = 0;  // Not initialized.
 
   for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
     buffer_state_[i].frame_id = last_encoded_frame_id_;
     buffer_state_[i].state = kBufferStartState;
   }
 
   // VP8 have 3 buffers available for prediction, with
   // max_number_of_video_buffers_used set to 1 we maximize the coding efficiency
   // however in this mode we can not skip frames in the receiver to catch up
@@ skipping 231 matching lines @@
         TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency);
     encoded_frame->reference_time = reference_time;
     encoded_frame->data.assign(
         static_cast<const uint8*>(pkt->data.frame.buf),
         static_cast<const uint8*>(pkt->data.frame.buf) + pkt->data.frame.sz);
     break;  // Done, since all data is provided in one CX_FRAME_PKT packet.
   }
   DCHECK(!encoded_frame->data.empty())
       << "BUG: Encoder must provide data since lagged encoding is disabled.";
 
+  // TODO(miu): Determine when/why encoding can produce zero-length data,
+  // which causes crypto crashes.  http://crbug.com/519022
+  if (!has_seen_zero_length_encoded_frame_ && encoded_frame->data.empty()) {
+    has_seen_zero_length_encoded_frame_ = true;
+
+    const char kZeroEncodeDetails[] = "zero-encode-details";
+    const std::string details = base::StringPrintf(
+        "SV/%c,id=%" PRIu32 ",rtp=%" PRIu32 ",br=%d,kfr=%c",
+        encoded_frame->dependency == EncodedFrame::KEY ? 'K' : 'D',
+        encoded_frame->frame_id, encoded_frame->rtp_timestamp,
+        static_cast<int>(config_.rc_target_bitrate),
+        key_frame_requested_ ? 'Y' : 'N');
+    base::debug::SetCrashKeyValue(kZeroEncodeDetails, details);
+    // Please forward crash reports to http://crbug.com/519022:
+    base::debug::DumpWithoutCrashing();
+    base::debug::ClearCrashKey(kZeroEncodeDetails);
+  }
+
   // Compute deadline utilization as the real-world time elapsed divided by the
   // frame duration.
   const base::TimeDelta processing_time = base::TimeTicks::Now() - start_time;
   encoded_frame->deadline_utilization =
       processing_time.InSecondsF() / predicted_frame_duration.InSecondsF();
 
   // Compute lossy utilization.  The VP8 encoder took an estimated guess at what
   // quantizer value would produce an encoded frame size as close to the target
   // as possible.  Now that the frame has been encoded and the number of bytes
   // is known, the perfect quantizer value (i.e., the one that should have been
@@ skipping 213 matching lines @@
   }
 }
 
 void Vp8Encoder::GenerateKeyFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_requested_ = true;
 }
 
 }  // namespace cast
 }  // namespace media