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

media/cast/sender/external_video_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/external_video_encoder.h"
 
 #include <cmath>
 
 #include "base/bind.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/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/stringprintf.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_types.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/vp8_quantizer_parser.h"
 #include "media/filters/h264_parser.h"
 
 namespace {
@@ skipping 65 matching lines @@
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
         status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
         video_encode_accelerator_(vea.Pass()),
         encoder_active_(false),
         next_frame_id_(0u),
         key_frame_encountered_(false),
         codec_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
         key_frame_quantizer_parsable_(false),
-        requested_bit_rate_(-1) {}
+        requested_bit_rate_(-1),
+        has_seen_zero_length_encoded_frame_(false) {}
 
   base::SingleThreadTaskRunner* task_runner() const {
     return task_runner_.get();
   }
 
   void Initialize(const gfx::Size& frame_size,
                   VideoCodecProfile codec_profile,
                   int start_bit_rate,
                   uint32 first_frame_id) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
@@ skipping 188 matching lines @@
               codec_profile_ == media::VP8PROFILE_ANY
                   ? static_cast<int>(QuantizerEstimator::MAX_VP8_QUANTIZER)
                   : static_cast<int>(MAX_H264_QUANTIZER);
           encoded_frame->lossy_utilization =
               bitrate_utilization * (quantizer / max_quantizer);
         }
       } else {
         quantizer_estimator_.Reset();
       }
 
+      // 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(
+            "%c/%c,id=%" PRIu32 ",rtp=%" PRIu32 ",br=%d,q=%zu,act=%c,ref=%d",

[brucedawson, 2015/11/02 21:22:59]

Unfortunately this line of code uses a C99 feature that VC++ does not have yet.
VC++ 2015 supports %zu, but VC++ 2013 does not.

The portable fix to this is to use PRIuS (similar to PRIu32), or use a cast to
convert the size_t variable to a fixed type.

Using %zu in VC++ is undefined behavior. In practice it means that the %zu is
ignored and all subsequent values will be misapplied.

+            codec_profile_ == media::VP8PROFILE_ANY ? 'V' : 'H',
+            key_frame ? 'K' : 'D', encoded_frame->frame_id,
+            encoded_frame->rtp_timestamp, request.target_bit_rate / 1000,
+            in_progress_frame_encodes_.size(), encoder_active_ ? 'Y' : 'N',
+            static_cast<int>(encoded_frame->referenced_frame_id % 1000));
+        base::debug::SetCrashKeyValue(kZeroEncodeDetails, details);
+        // Please forward crash reports to http://crbug.com/519022:
+        base::debug::DumpWithoutCrashing();
+        base::debug::ClearCrashKey(kZeroEncodeDetails);
+      }
+
       cast_environment_->PostTask(
           CastEnvironment::MAIN,
           FROM_HERE,
           base::Bind(&LogFrameEncodedEvent,
                      cast_environment_,
                      cast_environment_->Clock()->NowTicks(),
                      encoded_frame->rtp_timestamp,
                      encoded_frame->frame_id));
 
       cast_environment_->PostTask(
@@ skipping 131 matching lines @@
 
   // FIFO list.
   std::list<InProgressFrameEncode> in_progress_frame_encodes_;
 
   // The requested encode bit rate for the next frame.
   int requested_bit_rate_;
 
   // Used to compute utilization metrics for each frame.
   QuantizerEstimator quantizer_estimator_;
 
+  // Set to true once a frame with zero-length encoded data has been
+  // encountered.
+  // TODO(miu): Remove after discovering cause.  http://crbug.com/519022
+  bool has_seen_zero_length_encoded_frame_;
+
   DISALLOW_COPY_AND_ASSIGN(VEAClientImpl);
 };
 
 // static
 bool ExternalVideoEncoder::IsSupported(const VideoSenderConfig& video_config) {
   if (video_config.codec != CODEC_VIDEO_VP8 &&
       video_config.codec != CODEC_VIDEO_H264)
     return false;
 
   // TODO(miu): "Layering hooks" are needed to be able to query outside of
@@ skipping 297 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media