Eliminate video capture thread in renderer

content/renderer/media/video_capture_impl.cc

Index: content/renderer/media/video_capture_impl.cc
diff --git a/content/renderer/media/video_capture_impl.cc b/content/renderer/media/video_capture_impl.cc
index 30b43ddfcf4d41c46782c4b7229a354ab60218b4..fdd31a6932d5e2a8def59cc314ff42e45f87d98f 100644
--- a/content/renderer/media/video_capture_impl.cc
+++ b/content/renderer/media/video_capture_impl.cc
@@ -42,11 +42,9 @@ int VideoCaptureImpl::CaptureFrameRate() {
 
 VideoCaptureImpl::VideoCaptureImpl(
     const media::VideoCaptureSessionId session_id,
-    base::MessageLoopProxy* capture_message_loop_proxy,
     VideoCaptureMessageFilter* filter)
     : VideoCapture(),
       message_filter_(filter),
-      capture_message_loop_proxy_(capture_message_loop_proxy),
       io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
       device_id_(0),
       session_id_(session_id),
@@ -61,88 +59,55 @@ VideoCaptureImpl::~VideoCaptureImpl() {}
 void VideoCaptureImpl::Init() {
   if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
     io_message_loop_proxy_->PostTask(FROM_HERE,
-        base::Bind(&VideoCaptureImpl::AddDelegateOnIOThread,
+        base::Bind(&VideoCaptureImpl::Init,
                    base::Unretained(this)));
-  } else {
-    AddDelegateOnIOThread();
+    return;
   }
-}
-
-void VideoCaptureImpl::DeInit(base::Closure task) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoDeInitOnCaptureThread,
-                 base::Unretained(this), task));
-}
 
-void VideoCaptureImpl::StartCapture(
-    media::VideoCapture::EventHandler* handler,
-    const media::VideoCaptureParams& params) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoStartCaptureOnCaptureThread,
-                 base::Unretained(this), handler, params));
-}
-
-void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoStopCaptureOnCaptureThread,
-                 base::Unretained(this), handler));
-}
-
-void VideoCaptureImpl::OnBufferCreated(
-    base::SharedMemoryHandle handle,
-    int length, int buffer_id) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoBufferCreatedOnCaptureThread,
-                 base::Unretained(this), handle, length, buffer_id));
-}
-
-void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoBufferDestroyedOnCaptureThread,
-                 base::Unretained(this), buffer_id));
-}
-
-void VideoCaptureImpl::OnBufferReceived(
-    int buffer_id,
-    base::Time timestamp,
-    const media::VideoCaptureFormat& format) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoBufferReceivedOnCaptureThread,
-                 base::Unretained(this), buffer_id, timestamp, format));
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  message_filter_->AddDelegate(this);
 }
 
-void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoStateChangedOnCaptureThread,
-                 base::Unretained(this), state));
-}
+void VideoCaptureImpl::DeInit(base::Closure task) {
+  if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
+    io_message_loop_proxy_->PostTask(FROM_HERE,
+        base::Bind(&VideoCaptureImpl::DeInit,
+                   base::Unretained(this),
+                   task));
+    return;
+  }
 
-void VideoCaptureImpl::OnDelegateAdded(int32 device_id) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoDelegateAddedOnCaptureThread,
-                 base::Unretained(this), device_id));
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  if (state_ == VIDEO_CAPTURE_STATE_STARTED)
+    Send(new VideoCaptureHostMsg_Stop(device_id_));
+  message_filter_->RemoveDelegate(this);
+  task.Run();
 }
 
 void VideoCaptureImpl::SuspendCapture(bool suspend) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoSuspendCaptureOnCaptureThread,
-                 base::Unretained(this), suspend));
-}
-
-void VideoCaptureImpl::DoDeInitOnCaptureThread(base::Closure task) {
-  if (state_ == VIDEO_CAPTURE_STATE_STARTED)
-    Send(new VideoCaptureHostMsg_Stop(device_id_));
+  if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
+    io_message_loop_proxy_->PostTask(FROM_HERE,
+        base::Bind(&VideoCaptureImpl::SuspendCapture,
+                   base::Unretained(this),
+                   suspend));
+    return;
+  }
 
-  io_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::RemoveDelegateOnIOThread,
-                 base::Unretained(this), task));
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  suspended_ = suspend;
 }
 
-void VideoCaptureImpl::DoStartCaptureOnCaptureThread(
+void VideoCaptureImpl::StartCapture(
     media::VideoCapture::EventHandler* handler,
     const media::VideoCaptureParams& params) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
+    io_message_loop_proxy_->PostTask(FROM_HERE,
+        base::Bind(&VideoCaptureImpl::StartCapture,
+                   base::Unretained(this), handler, params));
+    return;
+  }
 
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     handler->OnError(this, 1);
     handler->OnRemoved(this);
@@ -183,9 +148,16 @@ void VideoCaptureImpl::DoStartCaptureOnCaptureThread(
   }
 }
 
-void VideoCaptureImpl::DoStopCaptureOnCaptureThread(
+void VideoCaptureImpl::StopCapture(
     media::VideoCapture::EventHandler* handler) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
+    io_message_loop_proxy_->PostTask(FROM_HERE,
+        base::Bind(&VideoCaptureImpl::StopCapture,
+                   base::Unretained(this), handler));
+    return;
+  }
+
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // A handler can be in only one client list.
   // If this handler is in any client list, we can just remove it from
@@ -202,10 +174,10 @@ void VideoCaptureImpl::DoStopCaptureOnCaptureThread(
   }
 }
 
-void VideoCaptureImpl::DoBufferCreatedOnCaptureThread(
+void VideoCaptureImpl::OnBufferCreated(
     base::SharedMemoryHandle handle,
     int length, int buffer_id) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // In case client calls StopCapture before the arrival of created buffer,
   // just close this buffer and return.
@@ -216,7 +188,7 @@ void VideoCaptureImpl::DoBufferCreatedOnCaptureThread(
 
   scoped_ptr<base::SharedMemory> shm(new base::SharedMemory(handle, false));
   if (!shm->Map(length)) {
-    DLOG(ERROR) << "DoBufferCreatedOnCaptureThread: Map() failed.";
+    DLOG(ERROR) << "SharedMemory::Map() failed.";

[Jói, 2013/12/27 13:34:35]

nit: "OnBufferCreated: Map failed." might give more context.

[Alpha Left Google, 2013/12/27 21:30:01]

Done.

     return;
   }
 
@@ -228,8 +200,8 @@ void VideoCaptureImpl::DoBufferCreatedOnCaptureThread(
   DCHECK(inserted);
 }
 
-void VideoCaptureImpl::DoBufferDestroyedOnCaptureThread(int buffer_id) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
   if (iter == client_buffers_.end())
@@ -240,11 +212,11 @@ void VideoCaptureImpl::DoBufferDestroyedOnCaptureThread(int buffer_id) {
   client_buffers_.erase(iter);
 }
 
-void VideoCaptureImpl::DoBufferReceivedOnCaptureThread(
+void VideoCaptureImpl::OnBufferReceived(
     int buffer_id,
     base::Time timestamp,
     const media::VideoCaptureFormat& format) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
@@ -269,9 +241,9 @@ void VideoCaptureImpl::DoBufferReceivedOnCaptureThread(
           // base::TimeTicks instead of base::Time.  http://crbug.com/249215
           timestamp - base::Time::UnixEpoch(),
           media::BindToLoop(
-              capture_message_loop_proxy_,
+              io_message_loop_proxy_,
               base::Bind(
-                  &VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread,
+                  &VideoCaptureImpl::OnClientBufferFinished,
                   weak_this_factory_.GetWeakPtr(),
                   buffer_id,
                   buffer)));
@@ -280,15 +252,15 @@ void VideoCaptureImpl::DoBufferReceivedOnCaptureThread(
     it->first->OnFrameReady(this, frame);
 }
 
-void VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread(
+void VideoCaptureImpl::OnClientBufferFinished(
     int buffer_id,
     const scoped_refptr<ClientBuffer>& buffer) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
 }
 
-void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
@@ -332,9 +304,9 @@ void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
   }
 }
 
-void VideoCaptureImpl::DoDelegateAddedOnCaptureThread(int32 device_id) {
-  DVLOG(1) << "DoDelegateAdded: device_id " << device_id;
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+void VideoCaptureImpl::OnDelegateAdded(int32 device_id) {
+  DVLOG(1) << "OnDelegateAdded: device_id " << device_id;
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   device_id_ = device_id;
   for (ClientInfo::iterator it = clients_pending_on_filter_.begin();
@@ -346,15 +318,8 @@ void VideoCaptureImpl::DoDelegateAddedOnCaptureThread(int32 device_id) {
   }
 }
 
-void VideoCaptureImpl::DoSuspendCaptureOnCaptureThread(bool suspend) {
-  DVLOG(1) << "DoSuspendCapture: suspend " << (suspend ? "yes" : "no");
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-
-  suspended_ = suspend;
-}
-
 void VideoCaptureImpl::StopDevice() {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     state_ = VIDEO_CAPTURE_STATE_STOPPING;
@@ -364,7 +329,7 @@ void VideoCaptureImpl::StopDevice() {
 }
 
 void VideoCaptureImpl::RestartCapture() {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPED);
 
   int width = 0;
@@ -388,24 +353,13 @@ void VideoCaptureImpl::RestartCapture() {
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
   Send(new VideoCaptureHostMsg_Start(device_id_, session_id_, params_));
   state_ = VIDEO_CAPTURE_STATE_STARTED;
 }
 
-void VideoCaptureImpl::AddDelegateOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  message_filter_->AddDelegate(this);
-}
-
-void VideoCaptureImpl::RemoveDelegateOnIOThread(base::Closure task) {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  message_filter_->RemoveDelegate(this);
-  capture_message_loop_proxy_->PostTask(FROM_HERE, task);
-}
-
 void VideoCaptureImpl::Send(IPC::Message* message) {
   io_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(base::IgnoreResult(&VideoCaptureMessageFilter::Send),
@@ -415,7 +369,7 @@ void VideoCaptureImpl::Send(IPC::Message* message) {
 bool VideoCaptureImpl::RemoveClient(
     media::VideoCapture::EventHandler* handler,
     ClientInfo* clients) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   bool found = false;
 
   ClientInfo::iterator it = clients->find(handler);