Revert 236927 "Reorganize media::VideoCapture* types"

trunk/src/content/browser/renderer_host/media/video_capture_controller_unittest.cc

 // Copyright (c) 2012 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.
 
 // Unit test for VideoCaptureController.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 95 matching lines @@
   scoped_ptr<media::VideoCaptureDevice::Client> device_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureControllerTest);
 };
 
 // A simple test of VideoCaptureController's ability to add, remove, and keep
 // track of clients.
 TEST_F(VideoCaptureControllerTest, AddAndRemoveClients) {
   media::VideoCaptureParams session_100;
+  session_100.session_id = 100;
   session_100.requested_format = media::VideoCaptureFormat(
-      gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
+      320, 240, 30, media::ConstantResolutionVideoCaptureDevice);
+
   media::VideoCaptureParams session_200 = session_100;
+  session_200.session_id = 200;
 
   media::VideoCaptureParams session_300 = session_100;
+  session_300.session_id = 300;
 
   media::VideoCaptureParams session_400 = session_100;
+  session_400.session_id = 400;
 
   // Intentionally use the same route ID for two of the clients: the device_ids
   // are a per-VideoCaptureHost namespace, and can overlap across hosts.
   const VideoCaptureControllerID client_a_route_1(44);
   const VideoCaptureControllerID client_a_route_2(30);
   const VideoCaptureControllerID client_b_route_1(30);
   const VideoCaptureControllerID client_b_route_2(1);
 
   // Clients in controller: []
   ASSERT_EQ(0, controller_->GetClientCount())
       << "Client count should initially be zero.";
-  controller_->AddClient(client_a_route_1,
-                         client_a_.get(),
-                         base::kNullProcessHandle,
-                         100,
-                         session_100);
+  controller_->AddClient(client_a_route_1, client_a_.get(),
+                         base::kNullProcessHandle, session_100);
   // Clients in controller: [A/1]
   ASSERT_EQ(1, controller_->GetClientCount())
       << "Adding client A/1 should bump client count.";;
-  controller_->AddClient(client_a_route_2,
-                         client_a_.get(),
-                         base::kNullProcessHandle,
-                         200,
-                         session_200);
+  controller_->AddClient(client_a_route_2, client_a_.get(),
+                         base::kNullProcessHandle, session_200);
   // Clients in controller: [A/1, A/2]
   ASSERT_EQ(2, controller_->GetClientCount())
       << "Adding client A/2 should bump client count.";
-  controller_->AddClient(client_b_route_1,
-                         client_b_.get(),
-                         base::kNullProcessHandle,
-                         300,
-                         session_300);
+  controller_->AddClient(client_b_route_1, client_b_.get(),
+                         base::kNullProcessHandle, session_300);
   // Clients in controller: [A/1, A/2, B/1]
   ASSERT_EQ(3, controller_->GetClientCount())
       << "Adding client B/1 should bump client count.";
   ASSERT_EQ(200,
       controller_->RemoveClient(client_a_route_2, client_a_.get()))
       << "Removing client A/1 should return its session_id.";
   // Clients in controller: [A/1, B/1]
   ASSERT_EQ(2, controller_->GetClientCount());
   ASSERT_EQ(static_cast<int>(kInvalidMediaCaptureSessionId),
       controller_->RemoveClient(client_a_route_2, client_a_.get()))
       << "Removing a nonexistant client should fail.";
   // Clients in controller: [A/1, B/1]
   ASSERT_EQ(2, controller_->GetClientCount());
   ASSERT_EQ(300,
       controller_->RemoveClient(client_b_route_1, client_b_.get()))
       << "Removing client B/1 should return its session_id.";
   // Clients in controller: [A/1]
   ASSERT_EQ(1, controller_->GetClientCount());
-  controller_->AddClient(client_b_route_2,
-                         client_b_.get(),
-                         base::kNullProcessHandle,
-                         400,
-                         session_400);
+  controller_->AddClient(client_b_route_2, client_b_.get(),
+                         base::kNullProcessHandle, session_400);
   // Clients in controller: [A/1, B/2]
 
   EXPECT_CALL(*client_a_, DoEnded(client_a_route_1)).Times(1);
   controller_->StopSession(100);  // Session 100 == client A/1
   Mock::VerifyAndClearExpectations(client_a_.get());
   ASSERT_EQ(2, controller_->GetClientCount())
       << "Client should be closed but still exist after StopSession.";
   // Clients in controller: [A/1 (closed, removal pending), B/2]
   base::RunLoop().RunUntilIdle();
   // Clients in controller: [B/2]
@@ skipping 19 matching lines @@
   // Clients in controller: []
   ASSERT_EQ(0, controller_->GetClientCount())
       << "Client count should return to zero after all clients are gone.";
 }
 
 // This test will connect and disconnect several clients while simulating an
 // active capture device being started and generating frames. It runs on one
 // thread and is intended to behave deterministically.
 TEST_F(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
   media::VideoCaptureParams session_100;
+  session_100.session_id = 100;
   session_100.requested_format = media::VideoCaptureFormat(
-      gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
+      320, 240, 30, media::ConstantResolutionVideoCaptureDevice);
 
   media::VideoCaptureParams session_200 = session_100;
+  session_200.session_id = 200;
 
   media::VideoCaptureParams session_300 = session_100;
+  session_300.session_id = 300;
 
   media::VideoCaptureParams session_1 = session_100;
+  session_1.session_id = 1;
 
   gfx::Size capture_resolution(444, 200);
 
   // The device format needn't match the VideoCaptureParams (the camera can do
   // what it wants). Pick something random.
-  media::VideoCaptureFormat device_format(
-      gfx::Size(10, 10), 25, media::PIXEL_FORMAT_RGB24);
+  media::VideoCaptureCapability device_format(
+      10, 10, 25, media::PIXEL_FORMAT_RGB24,
+      media::ConstantResolutionVideoCaptureDevice);
 
   const VideoCaptureControllerID client_a_route_1(0xa1a1a1a1);
   const VideoCaptureControllerID client_a_route_2(0xa2a2a2a2);
   const VideoCaptureControllerID client_b_route_1(0xb1b1b1b1);
   const VideoCaptureControllerID client_b_route_2(0xb2b2b2b2);
 
   // Start with two clients.
-  controller_->AddClient(client_a_route_1,
-                         client_a_.get(),
-                         base::kNullProcessHandle,
-                         100,
-                         session_100);
-  controller_->AddClient(client_b_route_1,
-                         client_b_.get(),
-                         base::kNullProcessHandle,
-                         300,
-                         session_300);
-  controller_->AddClient(client_a_route_2,
-                         client_a_.get(),
-                         base::kNullProcessHandle,
-                         200,
-                         session_200);
+  controller_->AddClient(client_a_route_1, client_a_.get(),
+                         base::kNullProcessHandle, session_100);
+  controller_->AddClient(client_b_route_1, client_b_.get(),
+                         base::kNullProcessHandle, session_300);
+  controller_->AddClient(client_a_route_2, client_a_.get(),
+                         base::kNullProcessHandle, session_200);
   ASSERT_EQ(3, controller_->GetClientCount());
 
   // Now, simulate an incoming captured buffer from the capture device. As a
   // side effect this will cause the first buffer to be shared with clients.
   uint8 buffer_no = 1;
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer;
   buffer =
       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
   ASSERT_TRUE(buffer);
   memset(buffer->data(), buffer_no++, buffer->size());
@@ skipping 39 matching lines @@
 
   // The buffer should be delivered to the clients in any order.
   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(1);
   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(1);
   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(1);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Add a fourth client now that some buffers have come through.
-  controller_->AddClient(client_b_route_2,
-                         client_b_.get(),
-                         base::kNullProcessHandle,
-                         1,
-                         session_1);
+  controller_->AddClient(client_b_route_2, client_b_.get(),
+                         base::kNullProcessHandle, session_1);
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Third, fourth, and fifth buffers. Pretend they all arrive at the same time.
   for (int i = 0; i < kPoolSize; i++) {
     buffer = device_->ReserveOutputBuffer(media::VideoFrame::I420,
                                           capture_resolution);
     ASSERT_TRUE(buffer);
     memset(buffer->data(), buffer_no++, buffer->size());
     device_->OnIncomingCapturedBuffer(buffer,
                                       media::VideoFrame::I420,
@@ skipping 60 matching lines @@
   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(2);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
 }
 
 // Exercises the OnError() codepath of VideoCaptureController, and tests the
 // behavior of various operations after the error state has been signalled.
 TEST_F(VideoCaptureControllerTest, ErrorBeforeDeviceCreation) {
   media::VideoCaptureParams session_100;
+  session_100.session_id = 100;
   session_100.requested_format = media::VideoCaptureFormat(
-      gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
+    320, 240, 30, media::ConstantResolutionVideoCaptureDevice);
 
   media::VideoCaptureParams session_200 = session_100;
+  session_200.session_id = 200;
 
   const gfx::Size capture_resolution(320, 240);
 
   const VideoCaptureControllerID route_id(0x99);
 
   // Start with one client.
-  controller_->AddClient(
-      route_id, client_a_.get(), base::kNullProcessHandle, 100, session_100);
+  controller_->AddClient(route_id, client_a_.get(),
+                         base::kNullProcessHandle, session_100);
   device_->OnError();
   EXPECT_CALL(*client_a_, DoError(route_id)).Times(1);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
 
   // Second client connects after the error state. It also should get told of
   // the error.
   EXPECT_CALL(*client_b_, DoError(route_id)).Times(1);
-  controller_->AddClient(
-      route_id, client_b_.get(), base::kNullProcessHandle, 200, session_200);
+  controller_->AddClient(route_id, client_b_.get(),
+                         base::kNullProcessHandle, session_200);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer =
       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
   ASSERT_TRUE(buffer);
 
   device_->OnIncomingCapturedBuffer(
       buffer, media::VideoFrame::I420, capture_resolution, base::Time(), 30);
   buffer = NULL;
 
   base::RunLoop().RunUntilIdle();
 }
 
 // Exercises the OnError() codepath of VideoCaptureController, and tests the
 // behavior of various operations after the error state has been signalled.
 TEST_F(VideoCaptureControllerTest, ErrorAfterDeviceCreation) {
   media::VideoCaptureParams session_100;
+  session_100.session_id = 100;
   session_100.requested_format = media::VideoCaptureFormat(
-      gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
+      320, 240, 30, media::ConstantResolutionVideoCaptureDevice);
 
   media::VideoCaptureParams session_200 = session_100;
+  session_200.session_id = 200;
 
   const VideoCaptureControllerID route_id(0x99);
 
   // Start with one client.
-  controller_->AddClient(
-      route_id, client_a_.get(), base::kNullProcessHandle, 100, session_100);
-  media::VideoCaptureFormat device_format(
-      gfx::Size(10, 10), 25, media::PIXEL_FORMAT_ARGB);
+  controller_->AddClient(route_id, client_a_.get(),
+                         base::kNullProcessHandle, session_100);
+  // OnFrameInfo from the VCD should become a no-op after the error occurs.
+  media::VideoCaptureCapability device_format(
+      10, 10, 25, media::PIXEL_FORMAT_ARGB,
+      media::ConstantResolutionVideoCaptureDevice);
 
   // Start the device. Then, before the first buffer, signal an error and
   // deliver the buffer. The error should be propagated to clients; the buffer
   // should not be.
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
 
   const gfx::Size dims(320, 240);
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer =
       device_->ReserveOutputBuffer(media::VideoFrame::I420, dims);
   ASSERT_TRUE(buffer);
 
   device_->OnError();
   device_->OnIncomingCapturedBuffer(buffer,
                                     media::VideoFrame::I420,
                                     dims,
                                     base::Time(),
                                     device_format.frame_rate);
   buffer = NULL;
 
   EXPECT_CALL(*client_a_, DoError(route_id)).Times(1);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
 
   // Second client connects after the error state. It also should get told of
   // the error.
   EXPECT_CALL(*client_b_, DoError(route_id)).Times(1);
-  controller_->AddClient(
-      route_id, client_b_.get(), base::kNullProcessHandle, 200, session_200);
+  controller_->AddClient(route_id, client_b_.get(),
+                         base::kNullProcessHandle, session_200);
   Mock::VerifyAndClearExpectations(client_b_.get());
 }
 
 }  // namespace content