Fix for issue 696098 (potential video capture crash ChromeOS)

media/capture/video/video_capture_device_client.cc

 // Copyright 2015 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/capture/video/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 315 matching lines @@
     auto entry_iter =
         std::find(buffer_ids_known_by_receiver_.begin(),
                   buffer_ids_known_by_receiver_.end(), buffer_id_to_drop);
     if (entry_iter != buffer_ids_known_by_receiver_.end()) {
       buffer_ids_known_by_receiver_.erase(entry_iter);
       receiver_->OnBufferRetired(buffer_id_to_drop);
     }
   }
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return Buffer();
+
+  if (!base::ContainsValue(buffer_ids_known_by_receiver_, buffer_id)) {
+    receiver_->OnNewBufferHandle(
+        buffer_id,
+        base::MakeUnique<BufferPoolBufferHandleProvider>(buffer_pool_,
+                                                         buffer_id));
+    buffer_ids_known_by_receiver_.push_back(buffer_id);
+  }
+
   return MakeBufferStruct(buffer_pool_, buffer_id, frame_feedback_id);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
   DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   OnIncomingCapturedBufferExt(std::move(buffer), format, reference_time,
                               timestamp, gfx::Rect(format.frame_size),
                               VideoFrameMetadata());
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBufferExt(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp,
     gfx::Rect visible_rect,
     const VideoFrameMetadata& additional_metadata) {
   DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
 
-  if (!base::ContainsValue(buffer_ids_known_by_receiver_, buffer.id)) {
-    receiver_->OnNewBufferHandle(buffer.id, std::move(buffer.handle_provider));
-    buffer_ids_known_by_receiver_.push_back(buffer.id);
-  }
-
   VideoFrameMetadata metadata;
   metadata.MergeMetadataFrom(&additional_metadata);
   metadata.SetDouble(media::VideoFrameMetadata::FRAME_RATE, format.frame_rate);
   metadata.SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                         reference_time);
 
   mojom::VideoFrameInfoPtr info = mojom::VideoFrameInfo::New();
   info->timestamp = timestamp;
   info->pixel_format = format.pixel_format;
   info->storage_type = format.pixel_storage;
@@ skipping 89 matching lines @@
   auto buffer_access = buffer.handle_provider->GetHandleForInProcessAccess();
   memcpy(buffer_access->data(), data, length);
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(format.frame_size, format.frame_rate,
                          media::PIXEL_FORMAT_Y16, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 }  // namespace media