Add a flag in StopCapture to allow event handler to choose event notification.

content/renderer/media/video_capture_impl.cc

 // Copyright (c) 2011 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/video_capture_impl.h"
 
 #include "base/stl_util.h"
+#include "base/synchronization/waitable_event.h"
 #include "content/common/child_process.h"
 #include "content/common/media/video_capture_messages.h"
 
 VideoCaptureImpl::DIBBuffer::DIBBuffer(
     base::SharedMemory* d, media::VideoCapture::VideoFrameBuffer* ptr)
     : dib(d),
       mapped_memory(ptr) {}
 
 VideoCaptureImpl::DIBBuffer::~DIBBuffer() {
   delete dib;
@@ skipping 69 matching lines @@
 void VideoCaptureImpl::StartCapture(
     media::VideoCapture::EventHandler* handler,
     const VideoCaptureCapability& capability) {
   DCHECK_EQ(capability.raw_type, media::VideoFrame::I420);
 
   ml_proxy_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &VideoCaptureImpl::DoStartCapture, handler,
                         capability));
 }
 
-void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler) {
-  ml_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &VideoCaptureImpl::DoStopCapture, handler));
+void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler,
+                                   bool need_notification) {
+  if (need_notification) {
+    ml_proxy_->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &VideoCaptureImpl::DoStopCapture, handler,
+                          static_cast<base::WaitableEvent*>(NULL)));
+  } else {
+    base::WaitableEvent completion(false, false);
+    ml_proxy_->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &VideoCaptureImpl::DoStopCapture, handler,
+                          &completion));
+    completion.Wait();
+  }
 }
 
 void VideoCaptureImpl::FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) {
   ml_proxy_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &VideoCaptureImpl::DoFeedBuffer, buffer));
 }
 
 void VideoCaptureImpl::OnBufferCreated(
     base::SharedMemoryHandle handle,
     int length, int buffer_id) {
@@ skipping 96 matching lines @@
   current_params_.width = capability.width;
   current_params_.height = capability.height;
   current_params_.frame_per_second = capability.max_fps;
   DLOG(INFO) << "StartCapture: resolution ("
              << current_params_.width << ", " << current_params_.height << ")";
 
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::DoStopCapture(
-    media::VideoCapture::EventHandler* handler) {
+    media::VideoCapture::EventHandler* handler,
+    base::WaitableEvent* completion) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   ClientInfo::iterator it = pending_clients_.find(handler);
   if (it != pending_clients_.end()) {
-    handler->OnStopped(this);
     pending_clients_.erase(it);
+    if (!completion)
+      handler->OnStopped(this);
+    else
+      completion->Signal();
     return;
   }
 
   if (clients_.find(handler) == clients_.end())
     return;
 
-  handler->OnStopped(this);
+  if (!completion)
+    handler->OnStopped(this);
+  else
+    completion->Signal();
   clients_.erase(handler);
   master_clients_.remove(handler);
 
   // Still have at least one master client.
   if (master_clients_.size() > 0)
     return;
 
   // TODO(wjia): Is it really needed to handle resolution change for non-master
   // clients, except no client case?
   if (clients_.size() > 0) {
@@ skipping 206 matching lines @@
 }
 
 void VideoCaptureImpl::Send(IPC::Message* message) {
   base::MessageLoopProxy* io_message_loop_proxy =
       ChildProcess::current()->io_message_loop_proxy();
 
   io_message_loop_proxy->PostTask(FROM_HERE,
       NewRunnableMethod(message_filter_.get(),
                         &VideoCaptureMessageFilter::Send, message));
 }