create one video capture message filter per renderer process

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 "content/common/child_process.h"
 #include "content/common/video_capture_messages.h"
 
 VideoCaptureImpl::DIBBuffer::DIBBuffer(
@@ skipping 50 matching lines @@
     io_message_loop_proxy->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::AddDelegateOnIOThread));
     return;
   }
 
   AddDelegateOnIOThread();
 }
 
 void VideoCaptureImpl::DeInit(Task* task) {
   if (state_ == kStarted)
-    message_filter_->Send(new VideoCaptureHostMsg_Stop(0, device_id_));
+    Send(new VideoCaptureHostMsg_Stop(0, device_id_));
 
   base::MessageLoopProxy* io_message_loop_proxy =
       ChildProcess::current()->io_message_loop_proxy();
 
   if (!io_message_loop_proxy->BelongsToCurrentThread()) {
     io_message_loop_proxy->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::RemoveDelegateOnIOThread,
                           task));
     return;
   }
@@ skipping 140 matching lines @@
 void VideoCaptureImpl::OnBufferReceived(TransportDIB::Handle handle,
                                         base::Time timestamp) {
   if (!ml_proxy_->BelongsToCurrentThread()) {
     ml_proxy_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::OnBufferReceived,
                           handle, timestamp));
     return;
   }
 
   if (state_ != kStarted) {
-    message_filter_->Send(
-        new VideoCaptureHostMsg_BufferReady(0, device_id_, handle));
+    Send(new VideoCaptureHostMsg_BufferReady(0, device_id_, handle));
     return;
   }
 
   media::VideoCapture::VideoFrameBuffer* buffer;
   CachedDIB::iterator it;
   for (it = cached_dibs_.begin(); it != cached_dibs_.end(); it++) {
     if ((*it)->dib->handle() == handle)
       break;
   }
   if (it == cached_dibs_.end()) {
     TransportDIB* dib = TransportDIB::Map(handle);
     buffer = new VideoFrameBuffer();
     buffer->memory_pointer = dib->memory();
     buffer->buffer_size = dib->size();
     buffer->width = width_;
     buffer->height = height_;
 
     DIBBuffer* dib_buffer = new DIBBuffer(dib, buffer);
     cached_dibs_.push_back(dib_buffer);
   } else {
     buffer = (*it)->mapped_memory;
   }
 
   // TODO(wjia): handle buffer sharing with downstream modules.
   for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); it++) {
     it->first->OnBufferReady(this, buffer);
   }
 
-  message_filter_->Send(
-      new VideoCaptureHostMsg_BufferReady(0, device_id_, handle));
+  Send(new VideoCaptureHostMsg_BufferReady(0, device_id_, handle));
 }
 
 void VideoCaptureImpl::OnStateChanged(
     const media::VideoCapture::State& state) {
   if (!ml_proxy_->BelongsToCurrentThread()) {
     ml_proxy_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::OnStateChanged, state));
     return;
   }
 
@@ skipping 61 matching lines @@
 
 void VideoCaptureImpl::StopDevice() {
   if (!ml_proxy_->BelongsToCurrentThread()) {
     ml_proxy_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::StopDevice));
     return;
   }
 
   if (state_ == kStarted) {
     state_ = kStopping;
-    message_filter_->Send(new VideoCaptureHostMsg_Stop(0, device_id_));
+    Send(new VideoCaptureHostMsg_Stop(0, device_id_));
     width_ = height_ = 0;
   }
 }
 
 void VideoCaptureImpl::RestartCapture() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopped);
 
   width_ = new_width_;
   height_ = new_height_;
   new_width_ = 0;
   new_height_ = 0;
 
   DLOG(INFO) << "RestartCapture, " << width_ << ", " << height_;
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
   media::VideoCaptureParams params;
   params.width = width_;
   params.height = height_;
   params.session_id = session_id_;
 
-  message_filter_->Send(new VideoCaptureHostMsg_Start(0, device_id_, params));
+  Send(new VideoCaptureHostMsg_Start(0, device_id_, params));
   state_ = kStarted;
   for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); it++) {
     it->first->OnStarted(this);
   }
 }
 
 void VideoCaptureImpl::AddDelegateOnIOThread() {
   message_filter_->AddDelegate(this);
 }
 
 void VideoCaptureImpl::RemoveDelegateOnIOThread(Task* task) {
   base::ScopedTaskRunner task_runner(task);
   message_filter_->RemoveDelegate(this);
 }
+
+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));
+}