use control message instead of routed for video capture

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-inl.h"
 #include "content/common/child_process.h"
 #include "content/common/media/video_capture_messages.h"
 
@@ skipping 54 matching lines @@
     io_message_loop_proxy->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::AddDelegateOnIOThread));
     return;
   }
 
   AddDelegateOnIOThread();
 }
 
 void VideoCaptureImpl::DeInit(Task* task) {
   if (state_ == kStarted)
-    Send(new VideoCaptureHostMsg_Stop(0, device_id_));
+    Send(new VideoCaptureHostMsg_Stop(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 199 matching lines @@
   buffer->height = height_;
 
   DIBBuffer* dib_buffer = new DIBBuffer(dib, buffer);
   cached_dibs_[buffer_id] = dib_buffer;
 }
 
 void VideoCaptureImpl::DoBufferReceived(int buffer_id, base::Time timestamp) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   if (state_ != kStarted) {
-    Send(new VideoCaptureHostMsg_BufferReady(0, device_id_, buffer_id));
+    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
     return;
   }
 
   media::VideoCapture::VideoFrameBuffer* buffer;
   DCHECK(cached_dibs_.find(buffer_id) != cached_dibs_.end());
   buffer = cached_dibs_[buffer_id]->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);
   }
 
-  Send(new VideoCaptureHostMsg_BufferReady(0, device_id_, buffer_id));
+  Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
 }
 
 void VideoCaptureImpl::DoStateChanged(const media::VideoCapture::State& state) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   switch (state) {
     case media::VideoCapture::kStarted:
       for (ClientInfo::iterator it = clients_.begin();
            it != clients_.end(); it++) {
         it->first->OnStarted(this);
@@ skipping 48 matching lines @@
 
 void VideoCaptureImpl::StopDevice() {
   if (!ml_proxy_->BelongsToCurrentThread()) {
     ml_proxy_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &VideoCaptureImpl::StopDevice));
     return;
   }
 
   if (state_ == kStarted) {
     state_ = kStopping;
-    Send(new VideoCaptureHostMsg_Stop(0, device_id_));
+    Send(new VideoCaptureHostMsg_Stop(device_id_));
     width_ = height_ = 0;
     STLDeleteContainerPairSecondPointers(cached_dibs_.begin(),
                                          cached_dibs_.end());
     cached_dibs_.clear();
   }
 }
 
 void VideoCaptureImpl::RestartCapture() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopped);
@@ skipping 10 matching lines @@
 void VideoCaptureImpl::StartCaptureInternal() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
   media::VideoCaptureParams params;
   params.width = width_;
   params.height = height_;
   params.frame_per_second = frame_rate_;
   params.session_id = session_id_;
 
-  Send(new VideoCaptureHostMsg_Start(0, device_id_, params));
+  Send(new VideoCaptureHostMsg_Start(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));
 }