ImageCapture: avoid several grabFrame()s in flight, beef up content_browsertests

content/renderer/media/image_capture_frame_grabber.cc

 // Copyright 2016 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/image_capture_frame_grabber.h"
 
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 88 matching lines @@
     libyuv::ARGBCopyYToAlpha(frame->visible_data(media::VideoFrame::kAPlane),
                              frame->stride(media::VideoFrame::kAPlane),
                              static_cast<uint8*>(pixmap.writable_addr()),
                              pixmap.width() * 4, pixmap.width(),
                              pixmap.height());
   }
 
   callback.Run(surface->makeImageSnapshot());
 }
 
-ImageCaptureFrameGrabber::ImageCaptureFrameGrabber() : weak_factory_(this) {}
+ImageCaptureFrameGrabber::ImageCaptureFrameGrabber()
+    : frame_grab_in_progress_(false), weak_factory_(this) {}
 
 ImageCaptureFrameGrabber::~ImageCaptureFrameGrabber() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void ImageCaptureFrameGrabber::grabFrame(
     blink::WebMediaStreamTrack* track,
     WebImageCaptureGrabFrameCallbacks* callbacks) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!!callbacks);
 
   DCHECK(track && !track->isNull() && track->getTrackData());
   DCHECK_EQ(blink::WebMediaStreamSource::TypeVideo, track->source().getType());
 
+  if (frame_grab_in_progress_) {
+    // Reject grabFrame()s too close back to back.
+    callbacks->onError();
+    return;
+  }
+
   ScopedWebCallbacks<WebImageCaptureGrabFrameCallbacks> scoped_callbacks =
       make_scoped_web_callbacks(callbacks, base::Bind(&OnError));
 
   // A SingleShotFrameHandler is bound and given to the Track to guarantee that
   // only one VideoFrame is converted and delivered to OnSkImage(), otherwise
   // SKImages might be sent to resolved |callbacks| while DisconnectFromTrack()
   // is being processed, which might be further held up if UI is busy, see
   // https://crbug.com/623042.
+  frame_grab_in_progress_ = true;
   MediaStreamVideoSink::ConnectToTrack(
       *track, base::Bind(&SingleShotFrameHandler::OnVideoFrameOnIOThread,
                          make_scoped_refptr(new SingleShotFrameHandler),
                          media::BindToCurrentLoop(
                              base::Bind(&ImageCaptureFrameGrabber::OnSkImage,
                                         weak_factory_.GetWeakPtr(),
                                         base::Passed(&scoped_callbacks)))),
       false);
 }
 
 void ImageCaptureFrameGrabber::OnSkImage(
     ScopedWebCallbacks<blink::WebImageCaptureGrabFrameCallbacks> callbacks,
     sk_sp<SkImage> image) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   MediaStreamVideoSink::DisconnectFromTrack();
+  frame_grab_in_progress_ = false;
   if (image)
     callbacks.PassCallbacks()->onSuccess(image);
   else
     callbacks.PassCallbacks()->onError();
 }
 
 }  // namespace content