use control message instead of routed for video capture

content/browser/renderer_host/media/video_capture_host_unittest.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 <map>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 10 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::Return;
 
-// IPC::Msg.routing_id.
-static const int32 kRouteId = 200;
 // Id used to identify the capture session between renderer and
 // video_capture_host.
 static const int kDeviceId = 1;
 // Id of a video capture device
 static const media::VideoCaptureSessionId kTestFakeDeviceId =
     media_stream::VideoCaptureManager::kStartOpenSessionId;
 
 // Define to enable test where video is dumped to file.
 // #define DUMP_VIDEO
 
@@ skipping 27 matching lines @@
 
 class MockVideoCaptureHost : public VideoCaptureHost {
  public:
   MockVideoCaptureHost() : return_buffers_(false), dump_video_(false) {}
   virtual ~MockVideoCaptureHost() {
     STLDeleteContainerPairSecondPointers(filled_dib_.begin(),
                                          filled_dib_.end());
   }
 
   // A list of mock methods.
-  MOCK_METHOD5(OnNewBufferCreated,
-               void(int routing_id, int device_id,
-                    base::SharedMemoryHandle handle,
+  MOCK_METHOD4(OnNewBufferCreated,
+               void(int device_id, base::SharedMemoryHandle handle,
                     int length, int buffer_id));
   MOCK_METHOD3(OnBufferFilled,
-               void(int routing_id, int device_id, int buffer_id));
-  MOCK_METHOD3(OnStateChanged,
-               void(int routing_id, int device_id,
-                    media::VideoCapture::State state));
-  MOCK_METHOD2(OnDeviceInfo, void(int routing_id, int device_id));
+               void(int device_id, int buffer_id, base::Time timestamp));
+  MOCK_METHOD2(OnStateChanged,
+               void(int device_id, media::VideoCapture::State state));
+  MOCK_METHOD1(OnDeviceInfo, void(int device_id));
 
   // Use class DumpVideo to write I420 video to file.
   void SetDumpVideo(bool enable) {
     dump_video_ = enable;
   }
   void SetReturnReceviedDibs(bool enable) {
     return_buffers_ = enable;
   }
 
   // Return Dibs we currently have received.
   void ReturnReceivedDibs(int device_id)  {
     int handle = GetReceivedDib();
     while (handle) {
-      IPC::Message msg;
-      msg.set_routing_id(kRouteId);
-      this->OnReceiveEmptyBuffer(msg, device_id, handle);
+      this->OnReceiveEmptyBuffer(device_id, handle);
       handle = GetReceivedDib();
     }
   }
   int GetReceivedDib() {
     if (filled_dib_.empty())
       return 0;
     std::map<int, base::SharedMemory*>::iterator it = filled_dib_.begin();
     int h = it->first;
     delete it->second;
     filled_dib_.erase(it);
 
     return h;
   }
 
  private:
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   virtual bool Send(IPC::Message* message) {
     CHECK(message);
 
     // In this method we dispatch the messages to the according handlers as if
     // we are the renderer.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureHost, *message)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnNewBufferCreated)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferFilled)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnStateChanged)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceInfo, OnDeviceInfo)
+      IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnNewBufferCreatedDispatch)
+      IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferFilledDispatch)
+      IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnStateChangedDispatch)
+      IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceInfo, OnDeviceInfoDispatch)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
   // These handler methods do minimal things and delegate to the mock methods.
-  void OnNewBufferCreated(const IPC::Message& msg, int device_id,
-                          base::SharedMemoryHandle handle,
-                          int length, int buffer_id) {
-    OnNewBufferCreated(msg.routing_id(), device_id, handle, length, buffer_id);
+  void OnNewBufferCreatedDispatch(int device_id,
+                                  base::SharedMemoryHandle handle,
+                                  int length, int buffer_id) {
+    OnNewBufferCreated(device_id, handle, length, buffer_id);
     base::SharedMemory* dib = new base::SharedMemory(handle, false);
     dib->Map(length);
     filled_dib_[buffer_id] = dib;
   }
 
-  void OnBufferFilled(const IPC::Message& msg, int device_id,
-                      int buffer_id) {
+  void OnBufferFilledDispatch(int device_id, int buffer_id,
+                              base::Time timestamp) {
     if (dump_video_) {
       base::SharedMemory* dib = filled_dib_[buffer_id];
       ASSERT_TRUE(dib != NULL);
       dumper_.NewVideoFrame(dib->memory());
     }
 
-    OnBufferFilled(msg.routing_id(), device_id, buffer_id);
+    OnBufferFilled(device_id, buffer_id, timestamp);
     if (return_buffers_) {
-      VideoCaptureHost::OnReceiveEmptyBuffer(msg, device_id, buffer_id);
+      VideoCaptureHost::OnReceiveEmptyBuffer(device_id, buffer_id);
     }
   }
 
-  void OnStateChanged(const IPC::Message& msg, int device_id,
-                      media::VideoCapture::State state) {
-    OnStateChanged(msg.routing_id(), device_id, state);
+  void OnStateChangedDispatch(int device_id,
+                              media::VideoCapture::State state) {
+    OnStateChanged(device_id, state);
   }
 
-  void OnDeviceInfo(const IPC::Message& msg, int device_id,
-                      media::VideoCaptureParams params) {
+  void OnDeviceInfoDispatch(int device_id,
+                            media::VideoCaptureParams params) {
     if (dump_video_) {
       dumper_.StartDump(params.width, params.height);
     }
-    OnDeviceInfo(msg.routing_id(), device_id);
+    OnDeviceInfo(device_id);
   }
 
   std::map<int, base::SharedMemory*> filled_dib_;
   bool return_buffers_;
   bool dump_video_;
   DumpVideo dumper_;
 };
 
 ACTION_P(ExitMessageLoop, message_loop) {
   message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
@@ skipping 18 matching lines @@
 
     // Simulate IPC channel connected.
     host_->OnChannelConnected(base::GetCurrentProcId());
   }
 
   virtual void TearDown() {
     // Verifies and removes the expectations on host_ and
     // returns true iff successful.
     Mock::VerifyAndClearExpectations(host_);
 
-    EXPECT_CALL(*host_, OnStateChanged(kRouteId, kDeviceId,
+    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                        media::VideoCapture::kStopped))
         .Times(AnyNumber());
 
     // Simulate closing the IPC channel.
     host_->OnChannelClosing();
 
     // Release the reference to the mock object. The object will be destructed
     // on message_loop_.
     host_ = NULL;
 
@@ skipping 22 matching lines @@
   void SyncWithVideoCaptureManagerThread() {
     message_loop_->PostTask(
         FROM_HERE, NewRunnableFunction(&PostQuitOnVideoCaptureManagerThread,
                                        message_loop_.get()));
     message_loop_->Run();
   }
 
   void StartCapture() {
     InSequence s;
     // 1. Newly created buffers will arrive.
-    EXPECT_CALL(*host_, OnNewBufferCreated(kRouteId, kDeviceId, _, _, _))
+    EXPECT_CALL(*host_, OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return());
 
     // 2. First - get info about the new resolution
-    EXPECT_CALL(*host_, OnDeviceInfo(kRouteId, kDeviceId));
+    EXPECT_CALL(*host_, OnDeviceInfo(kDeviceId));
 
     // 3. Change state to started
-    EXPECT_CALL(*host_, OnStateChanged(kRouteId, kDeviceId,
+    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                        media::VideoCapture::kStarted));
 
     // 4. First filled buffer will arrive.
-    EXPECT_CALL(*host_, OnBufferFilled(kRouteId, kDeviceId, _))
+    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-
     media::VideoCaptureParams params;
     params.width = 352;
     params.height = 288;
     params.frame_per_second = 30;
     params.session_id = kTestFakeDeviceId;
-    host_->OnStartCapture(msg, kDeviceId, params);
+    host_->OnStartCapture(kDeviceId, params);
     message_loop_->Run();
   }
 
   void CaptureAndDumpVideo(int width, int heigt, int frame_rate) {
     InSequence s;
     // 1. First - get info about the new resolution
-    EXPECT_CALL(*host_, OnDeviceInfo(kRouteId, kDeviceId));
+    EXPECT_CALL(*host_, OnDeviceInfo(kDeviceId));
 
     // 2. Change state to started
-    EXPECT_CALL(*host_, OnStateChanged(kRouteId, kDeviceId,
+    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                        media::VideoCapture::kStarted));
 
     // 3. First filled buffer will arrive.
-    EXPECT_CALL(*host_, OnBufferFilled(kRouteId, kDeviceId, _))
+    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-
     media::VideoCaptureParams params;
     params.width = width;
     params.height = heigt;
     params.frame_per_second = frame_rate;
     params.session_id = kTestFakeDeviceId;
     host_->SetDumpVideo(true);
-    host_->OnStartCapture(msg, kDeviceId, params);
+    host_->OnStartCapture(kDeviceId, params);
     message_loop_->Run();
   }
 
   void StopCapture() {
-    EXPECT_CALL(*host_, OnStateChanged(kRouteId, kDeviceId,
+    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                        media::VideoCapture::kStopped))
         .Times(AtLeast(1));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-    host_->OnStopCapture(msg, kDeviceId);
+    host_->OnStopCapture(kDeviceId);
     host_->SetReturnReceviedDibs(true);
     host_->ReturnReceivedDibs(kDeviceId);
 
     SyncWithVideoCaptureManagerThread();
     host_->SetReturnReceviedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_EQ(0u, host_->entries_.size());
   }
 
   void NotifyPacketReady() {
-    EXPECT_CALL(*host_, OnBufferFilled(kRouteId, kDeviceId, _))
+    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_.get()))
         .RetiresOnSaturation();
     message_loop_->Run();
   }
 
   void ReturnReceivedPackets() {
     host_->ReturnReceivedDibs(kDeviceId);
   }
 
   void SimulateError() {
     // Expect a change state to error state  sent through IPC.
-    EXPECT_CALL(*host_, OnStateChanged(kRouteId, kDeviceId,
+    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                        media::VideoCapture::kError))
         .Times(1);
-    VideoCaptureControllerID id(kRouteId, kDeviceId);
+    VideoCaptureControllerID id(kDeviceId);
     host_->OnError(id);
     SyncWithVideoCaptureManagerThread();
   }
 
   scoped_refptr<MockVideoCaptureHost> host_;
  private:
   scoped_ptr<MessageLoop> message_loop_;
   scoped_ptr<BrowserThread> io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
@@ skipping 11 matching lines @@
   StopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCaptureErrorStop) {
   StartCapture();
   SimulateError();
   StopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCaptureError) {
-  EXPECT_CALL(*host_, OnStateChanged(kRouteId, kDeviceId,
+  EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
                                      media::VideoCapture::kStopped))
       .Times(0);
   StartCapture();
   NotifyPacketReady();
   SimulateError();
   base::PlatformThread::Sleep(200);
 }
 
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif