content/browser/renderer_host/media/video_capture_controller_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Unit test for VideoCaptureController.
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/run_loop.h"
  15 #include "content/browser/renderer_host/media/media_stream_provider.h"
  16 #include "content/browser/renderer_host/media/video_capture_controller.h"
  17 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
  18 #include "content/browser/renderer_host/media/video_capture_manager.h"
  19 #include "content/common/media/media_stream_options.h"
  20 #include "content/public/test/test_browser_thread_bundle.h"
  21 #include "gpu/command_buffer/common/mailbox_holder.h"
  22 #include "media/base/video_util.h"
  23 #include "media/video/capture/video_capture_types.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 using ::testing::InSequence;
  28 using ::testing::Mock;
  29
  30 namespace content {
  31
  32 class MockVideoCaptureControllerEventHandler
  33     : public VideoCaptureControllerEventHandler {
  34  public:
  35   explicit MockVideoCaptureControllerEventHandler(
  36       VideoCaptureController* controller)
  37       : controller_(controller) {}
  38   virtual ~MockVideoCaptureControllerEventHandler() {}
  39
  40   // These mock methods are delegated to by our fake implementation of
  41   // VideoCaptureControllerEventHandler, to be used in EXPECT_CALL().
  42   MOCK_METHOD1(DoBufferCreated, void(const VideoCaptureControllerID&));
  43   MOCK_METHOD1(DoBufferDestroyed, void(const VideoCaptureControllerID&));
  44   MOCK_METHOD1(DoBufferReady, void(const VideoCaptureControllerID&));
  45   MOCK_METHOD1(DoMailboxBufferReady, void(const VideoCaptureControllerID&));
  46   MOCK_METHOD1(DoEnded, void(const VideoCaptureControllerID&));
  47   MOCK_METHOD1(DoError, void(const VideoCaptureControllerID&));
  48
  49   virtual void OnError(const VideoCaptureControllerID& id) OVERRIDE {
  50     DoError(id);
  51   }
  52   virtual void OnBufferCreated(const VideoCaptureControllerID& id,
  53                                base::SharedMemoryHandle handle,
  54                                int length, int buffer_id) OVERRIDE {
  55     DoBufferCreated(id);
  56   }
  57   virtual void OnBufferDestroyed(const VideoCaptureControllerID& id,
  58                                  int buffer_id) OVERRIDE {
  59     DoBufferDestroyed(id);
  60   }
  61   virtual void OnBufferReady(const VideoCaptureControllerID& id,
  62                              int buffer_id,
  63                              const media::VideoCaptureFormat& format,
  64                              base::TimeTicks timestamp) OVERRIDE {
  65     DoBufferReady(id);
  66     base::MessageLoop::current()->PostTask(
  67         FROM_HERE,
  68         base::Bind(&VideoCaptureController::ReturnBuffer,
  69                    base::Unretained(controller_),
  70                    id,
  71                    this,
  72                    buffer_id,
  73                    std::vector<uint32>()));
  74   }
  75   virtual void OnMailboxBufferReady(const VideoCaptureControllerID& id,
  76                                     int buffer_id,
  77                                     const gpu::MailboxHolder& mailbox_holder,
  78                                     const media::VideoCaptureFormat& format,
  79                                     base::TimeTicks timestamp) OVERRIDE {
  80     DoMailboxBufferReady(id);
  81     // Use a very different syncpoint value when returning a new syncpoint.
  82     std::vector<uint32> release_sync_points;
  83     release_sync_points.push_back(~mailbox_holder.sync_point);
  84     base::MessageLoop::current()->PostTask(
  85         FROM_HERE,
  86         base::Bind(&VideoCaptureController::ReturnBuffer,
  87                    base::Unretained(controller_),
  88                    id,
  89                    this,
  90                    buffer_id,
  91                    release_sync_points));
  92   }
  93   virtual void OnEnded(const VideoCaptureControllerID& id) OVERRIDE {
  94     DoEnded(id);
  95     // OnEnded() must respond by (eventually) unregistering the client.
  96     base::MessageLoop::current()->PostTask(FROM_HERE,
  97         base::Bind(base::IgnoreResult(&VideoCaptureController::RemoveClient),
  98                    base::Unretained(controller_), id, this));
  99   }
 100
 101   VideoCaptureController* controller_;
 102 };
 103
 104 // Test class.
 105 class VideoCaptureControllerTest : public testing::Test {
 106  public:
 107   VideoCaptureControllerTest() {}
 108   virtual ~VideoCaptureControllerTest() {}
 109
 110  protected:
 111   static const int kPoolSize = 3;
 112
 113   virtual void SetUp() OVERRIDE {
 114     controller_.reset(new VideoCaptureController());
 115     device_ = controller_->NewDeviceClient().Pass();
 116     client_a_.reset(new MockVideoCaptureControllerEventHandler(
 117         controller_.get()));
 118     client_b_.reset(new MockVideoCaptureControllerEventHandler(
 119         controller_.get()));
 120   }
 121
 122   virtual void TearDown() OVERRIDE {
 123     base::RunLoop().RunUntilIdle();
 124   }
 125
 126   scoped_refptr<media::VideoFrame> WrapI420Buffer(
 127       const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer,
 128       gfx::Size dimensions) {
 129     return media::VideoFrame::WrapExternalPackedMemory(
 130         media::VideoFrame::I420,
 131         dimensions,
 132         gfx::Rect(dimensions),
 133         dimensions,
 134         reinterpret_cast<uint8*>(buffer->data()),
 135         media::VideoFrame::AllocationSize(media::VideoFrame::I420, dimensions),
 136         base::SharedMemory::NULLHandle(),
 137         base::TimeDelta(),
 138         base::Closure());
 139   }
 140
 141   scoped_refptr<media::VideoFrame> WrapMailboxBuffer(
 142       const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer,
 143       scoped_ptr<gpu::MailboxHolder> holder,
 144       const media::VideoFrame::ReleaseMailboxCB& release_cb,
 145       gfx::Size dimensions) {
 146     return media::VideoFrame::WrapNativeTexture(
 147         holder.Pass(),
 148         release_cb,
 149         dimensions,
 150         gfx::Rect(dimensions),
 151         dimensions,
 152         base::TimeDelta(),
 153         media::VideoFrame::ReadPixelsCB());
 154   }
 155
 156   TestBrowserThreadBundle bundle_;
 157   scoped_ptr<MockVideoCaptureControllerEventHandler> client_a_;
 158   scoped_ptr<MockVideoCaptureControllerEventHandler> client_b_;
 159   scoped_ptr<VideoCaptureController> controller_;
 160   scoped_ptr<media::VideoCaptureDevice::Client> device_;
 161
 162  private:
 163   DISALLOW_COPY_AND_ASSIGN(VideoCaptureControllerTest);
 164 };
 165
 166 // A simple test of VideoCaptureController's ability to add, remove, and keep
 167 // track of clients.
 168 TEST_F(VideoCaptureControllerTest, AddAndRemoveClients) {
 169   media::VideoCaptureParams session_100;
 170   session_100.requested_format = media::VideoCaptureFormat(
 171       gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 172   media::VideoCaptureParams session_200 = session_100;
 173
 174   media::VideoCaptureParams session_300 = session_100;
 175
 176   media::VideoCaptureParams session_400 = session_100;
 177
 178   // Intentionally use the same route ID for two of the clients: the device_ids
 179   // are a per-VideoCaptureHost namespace, and can overlap across hosts.
 180   const VideoCaptureControllerID client_a_route_1(44);
 181   const VideoCaptureControllerID client_a_route_2(30);
 182   const VideoCaptureControllerID client_b_route_1(30);
 183   const VideoCaptureControllerID client_b_route_2(1);
 184
 185   // Clients in controller: []
 186   ASSERT_EQ(0, controller_->GetClientCount())
 187       << "Client count should initially be zero.";
 188   controller_->AddClient(client_a_route_1,
 189                          client_a_.get(),
 190                          base::kNullProcessHandle,
 191                          100,
 192                          session_100);
 193   // Clients in controller: [A/1]
 194   ASSERT_EQ(1, controller_->GetClientCount())
 195       << "Adding client A/1 should bump client count.";
 196   controller_->AddClient(client_a_route_2,
 197                          client_a_.get(),
 198                          base::kNullProcessHandle,
 199                          200,
 200                          session_200);
 201   // Clients in controller: [A/1, A/2]
 202   ASSERT_EQ(2, controller_->GetClientCount())
 203       << "Adding client A/2 should bump client count.";
 204   controller_->AddClient(client_b_route_1,
 205                          client_b_.get(),
 206                          base::kNullProcessHandle,
 207                          300,
 208                          session_300);
 209   // Clients in controller: [A/1, A/2, B/1]
 210   ASSERT_EQ(3, controller_->GetClientCount())
 211       << "Adding client B/1 should bump client count.";
 212   ASSERT_EQ(200,
 213       controller_->RemoveClient(client_a_route_2, client_a_.get()))
 214       << "Removing client A/1 should return its session_id.";
 215   // Clients in controller: [A/1, B/1]
 216   ASSERT_EQ(2, controller_->GetClientCount());
 217   ASSERT_EQ(static_cast<int>(kInvalidMediaCaptureSessionId),
 218       controller_->RemoveClient(client_a_route_2, client_a_.get()))
 219       << "Removing a nonexistant client should fail.";
 220   // Clients in controller: [A/1, B/1]
 221   ASSERT_EQ(2, controller_->GetClientCount());
 222   ASSERT_EQ(300,
 223       controller_->RemoveClient(client_b_route_1, client_b_.get()))
 224       << "Removing client B/1 should return its session_id.";
 225   // Clients in controller: [A/1]
 226   ASSERT_EQ(1, controller_->GetClientCount());
 227   controller_->AddClient(client_b_route_2,
 228                          client_b_.get(),
 229                          base::kNullProcessHandle,
 230                          400,
 231                          session_400);
 232   // Clients in controller: [A/1, B/2]
 233
 234   EXPECT_CALL(*client_a_, DoEnded(client_a_route_1)).Times(1);
 235   controller_->StopSession(100);  // Session 100 == client A/1
 236   Mock::VerifyAndClearExpectations(client_a_.get());
 237   ASSERT_EQ(2, controller_->GetClientCount())
 238       << "Client should be closed but still exist after StopSession.";
 239   // Clients in controller: [A/1 (closed, removal pending), B/2]
 240   base::RunLoop().RunUntilIdle();
 241   // Clients in controller: [B/2]
 242   ASSERT_EQ(1, controller_->GetClientCount())
 243       << "Client A/1 should be deleted by now.";
 244   controller_->StopSession(200);  // Session 200 does not exist anymore
 245   // Clients in controller: [B/2]
 246   ASSERT_EQ(1, controller_->GetClientCount())
 247       << "Stopping non-existant session 200 should be a no-op.";
 248   controller_->StopSession(256);  // Session 256 never existed.
 249   // Clients in controller: [B/2]
 250   ASSERT_EQ(1, controller_->GetClientCount())
 251       << "Stopping non-existant session 256 should be a no-op.";
 252   ASSERT_EQ(static_cast<int>(kInvalidMediaCaptureSessionId),
 253       controller_->RemoveClient(client_a_route_1, client_a_.get()))
 254       << "Removing already-removed client A/1 should fail.";
 255   // Clients in controller: [B/2]
 256   ASSERT_EQ(1, controller_->GetClientCount())
 257       << "Removing non-existant session 200 should be a no-op.";
 258   ASSERT_EQ(400,
 259       controller_->RemoveClient(client_b_route_2, client_b_.get()))
 260       << "Removing client B/2 should return its session_id.";
 261   // Clients in controller: []
 262   ASSERT_EQ(0, controller_->GetClientCount())
 263       << "Client count should return to zero after all clients are gone.";
 264 }
 265
 266 static void CacheSyncPoint(std::vector<uint32>* called_release_sync_points,
 267                            const std::vector<uint32>& release_sync_points) {
 268   DCHECK(called_release_sync_points->empty());
 269   called_release_sync_points->assign(release_sync_points.begin(),
 270                                      release_sync_points.end());
 271 }
 272
 273 // This test will connect and disconnect several clients while simulating an
 274 // active capture device being started and generating frames. It runs on one
 275 // thread and is intended to behave deterministically.
 276 TEST_F(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
 277   media::VideoCaptureParams session_100;
 278   session_100.requested_format = media::VideoCaptureFormat(
 279       gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 280
 281   media::VideoCaptureParams session_200 = session_100;
 282
 283   media::VideoCaptureParams session_300 = session_100;
 284
 285   media::VideoCaptureParams session_1 = session_100;
 286
 287   gfx::Size capture_resolution(444, 200);
 288
 289   // The device format needn't match the VideoCaptureParams (the camera can do
 290   // what it wants). Pick something random.
 291   media::VideoCaptureFormat device_format(
 292       gfx::Size(10, 10), 25, media::PIXEL_FORMAT_RGB24);
 293
 294   const VideoCaptureControllerID client_a_route_1(0xa1a1a1a1);
 295   const VideoCaptureControllerID client_a_route_2(0xa2a2a2a2);
 296   const VideoCaptureControllerID client_b_route_1(0xb1b1b1b1);
 297   const VideoCaptureControllerID client_b_route_2(0xb2b2b2b2);
 298
 299   // Start with two clients.
 300   controller_->AddClient(client_a_route_1,
 301                          client_a_.get(),
 302                          base::kNullProcessHandle,
 303                          100,
 304                          session_100);
 305   controller_->AddClient(client_b_route_1,
 306                          client_b_.get(),
 307                          base::kNullProcessHandle,
 308                          300,
 309                          session_300);
 310   controller_->AddClient(client_a_route_2,
 311                          client_a_.get(),
 312                          base::kNullProcessHandle,
 313                          200,
 314                          session_200);
 315   ASSERT_EQ(3, controller_->GetClientCount());
 316
 317   // Now, simulate an incoming captured buffer from the capture device. As a
 318   // side effect this will cause the first buffer to be shared with clients.
 319   uint8 buffer_no = 1;
 320   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer;
 321   buffer =
 322       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
 323   ASSERT_TRUE(buffer);
 324   memset(buffer->data(), buffer_no++, buffer->size());
 325   {
 326     InSequence s;
 327     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1)).Times(1);
 328     EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(1);
 329   }
 330   {
 331     InSequence s;
 332     EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1)).Times(1);
 333     EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(1);
 334   }
 335   {
 336     InSequence s;
 337     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2)).Times(1);
 338     EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(1);
 339   }
 340   device_->OnIncomingCapturedVideoFrame(
 341       buffer,
 342       media::VideoCaptureFormat(capture_resolution,
 343                                 device_format.frame_rate,
 344                                 media::PIXEL_FORMAT_I420),
 345       WrapI420Buffer(buffer, capture_resolution),
 346       base::TimeTicks());
 347   buffer = NULL;
 348
 349   base::RunLoop().RunUntilIdle();
 350   Mock::VerifyAndClearExpectations(client_a_.get());
 351   Mock::VerifyAndClearExpectations(client_b_.get());
 352
 353   // Second buffer which ought to use the same shared memory buffer. In this
 354   // case pretend that the Buffer pointer is held by the device for a long
 355   // delay. This shouldn't affect anything.
 356   buffer =
 357       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
 358   ASSERT_TRUE(buffer);
 359   memset(buffer->data(), buffer_no++, buffer->size());
 360   device_->OnIncomingCapturedVideoFrame(
 361       buffer,
 362       media::VideoCaptureFormat(capture_resolution,
 363                                 device_format.frame_rate,
 364                                 media::PIXEL_FORMAT_I420),
 365       WrapI420Buffer(buffer, capture_resolution),
 366       base::TimeTicks());
 367   buffer = NULL;
 368
 369   // The buffer should be delivered to the clients in any order.
 370   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(1);
 371   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(1);
 372   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(1);
 373   base::RunLoop().RunUntilIdle();
 374   Mock::VerifyAndClearExpectations(client_a_.get());
 375   Mock::VerifyAndClearExpectations(client_b_.get());
 376
 377   // Add a fourth client now that some buffers have come through.
 378   controller_->AddClient(client_b_route_2,
 379                          client_b_.get(),
 380                          base::kNullProcessHandle,
 381                          1,
 382                          session_1);
 383   Mock::VerifyAndClearExpectations(client_b_.get());
 384
 385   // Third, fourth, and fifth buffers. Pretend they all arrive at the same time.
 386   for (int i = 0; i < kPoolSize; i++) {
 387     buffer = device_->ReserveOutputBuffer(media::VideoFrame::I420,
 388                                           capture_resolution);
 389     ASSERT_TRUE(buffer);
 390     memset(buffer->data(), buffer_no++, buffer->size());
 391     device_->OnIncomingCapturedVideoFrame(
 392         buffer,
 393         media::VideoCaptureFormat(capture_resolution,
 394                                   device_format.frame_rate,
 395                                   media::PIXEL_FORMAT_I420),
 396         WrapI420Buffer(buffer, capture_resolution),
 397         base::TimeTicks());
 398     buffer = NULL;
 399   }
 400   // ReserveOutputBuffer ought to fail now, because the pool is depleted.
 401   ASSERT_FALSE(device_->ReserveOutputBuffer(media::VideoFrame::I420,
 402                                             capture_resolution));
 403
 404   // The new client needs to be told of 3 buffers; the old clients only 2.
 405   EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_2)).Times(kPoolSize);
 406   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(kPoolSize);
 407   EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1))
 408       .Times(kPoolSize - 1);
 409   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(kPoolSize);
 410   EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2))
 411       .Times(kPoolSize - 1);
 412   EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(kPoolSize);
 413   EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1))
 414       .Times(kPoolSize - 1);
 415   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(kPoolSize);
 416   base::RunLoop().RunUntilIdle();
 417   Mock::VerifyAndClearExpectations(client_a_.get());
 418   Mock::VerifyAndClearExpectations(client_b_.get());
 419
 420   // Now test the interaction of client shutdown and buffer delivery.
 421   // Kill A1 via renderer disconnect (synchronous).
 422   controller_->RemoveClient(client_a_route_1, client_a_.get());
 423   // Kill B1 via session close (posts a task to disconnect).
 424   EXPECT_CALL(*client_b_, DoEnded(client_b_route_1)).Times(1);
 425   controller_->StopSession(300);
 426   // Queue up another buffer.
 427   buffer =
 428       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
 429   ASSERT_TRUE(buffer);
 430   memset(buffer->data(), buffer_no++, buffer->size());
 431   device_->OnIncomingCapturedVideoFrame(
 432       buffer,
 433       media::VideoCaptureFormat(capture_resolution,
 434                                 device_format.frame_rate,
 435                                 media::PIXEL_FORMAT_I420),
 436       WrapI420Buffer(buffer, capture_resolution),
 437       base::TimeTicks());
 438   buffer = NULL;
 439   buffer =
 440       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
 441   {
 442     // Kill A2 via session close (posts a task to disconnect, but A2 must not
 443     // be sent either of these two buffers).
 444     EXPECT_CALL(*client_a_, DoEnded(client_a_route_2)).Times(1);
 445     controller_->StopSession(200);
 446   }
 447   ASSERT_TRUE(buffer);
 448   memset(buffer->data(), buffer_no++, buffer->size());
 449   device_->OnIncomingCapturedVideoFrame(
 450       buffer,
 451       media::VideoCaptureFormat(capture_resolution,
 452                                 device_format.frame_rate,
 453                                 media::PIXEL_FORMAT_I420),
 454       WrapI420Buffer(buffer, capture_resolution),
 455       base::TimeTicks());
 456   buffer = NULL;
 457   // B2 is the only client left, and is the only one that should
 458   // get the buffer.
 459   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(2);
 460   base::RunLoop().RunUntilIdle();
 461   Mock::VerifyAndClearExpectations(client_a_.get());
 462   Mock::VerifyAndClearExpectations(client_b_.get());
 463
 464   // Allocate all buffers from the buffer pool, half as SHM buffer and half as
 465   // mailbox buffers.  Make sure of different counts though.
 466   int shm_buffers = kPoolSize / 2;
 467   int mailbox_buffers = kPoolSize - shm_buffers;
 468   if (shm_buffers == mailbox_buffers) {
 469     shm_buffers--;
 470     mailbox_buffers++;
 471   }
 472
 473   for (int i = 0; i < shm_buffers; ++i) {
 474     buffer = device_->ReserveOutputBuffer(media::VideoFrame::I420,
 475                                           capture_resolution);
 476     ASSERT_TRUE(buffer);
 477     device_->OnIncomingCapturedVideoFrame(
 478         buffer,
 479         media::VideoCaptureFormat(capture_resolution,
 480                                   device_format.frame_rate,
 481                                   media::PIXEL_FORMAT_I420),
 482         WrapI420Buffer(buffer, capture_resolution),
 483         base::TimeTicks());
 484     buffer = NULL;
 485   }
 486   std::vector<uint32> mailbox_syncpoints(mailbox_buffers);
 487   std::vector<std::vector<uint32> > release_syncpoint_vectors(mailbox_buffers);
 488   for (int i = 0; i < mailbox_buffers; ++i) {
 489     buffer = device_->ReserveOutputBuffer(media::VideoFrame::NATIVE_TEXTURE,
 490                                           gfx::Size(0, 0));
 491     ASSERT_TRUE(buffer);
 492     mailbox_syncpoints[i] = i;
 493     device_->OnIncomingCapturedVideoFrame(
 494         buffer,
 495         media::VideoCaptureFormat(capture_resolution,
 496                                   device_format.frame_rate,
 497                                   media::PIXEL_FORMAT_TEXTURE),
 498         WrapMailboxBuffer(
 499             buffer,
 500             make_scoped_ptr(new gpu::MailboxHolder(
 501                 gpu::Mailbox(), 0, mailbox_syncpoints[i])),
 502             base::Bind(&CacheSyncPoint, &release_syncpoint_vectors[i]),
 503             capture_resolution),
 504         base::TimeTicks());
 505     buffer = NULL;
 506   }
 507   // ReserveOutputBuffers ought to fail now regardless of buffer format, because
 508   // the pool is depleted.
 509   ASSERT_FALSE(device_->ReserveOutputBuffer(media::VideoFrame::I420,
 510                                             capture_resolution));
 511   ASSERT_FALSE(device_->ReserveOutputBuffer(media::VideoFrame::NATIVE_TEXTURE,
 512                                             gfx::Size(0, 0)));
 513   EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(shm_buffers);
 514   EXPECT_CALL(*client_b_, DoMailboxBufferReady(client_b_route_2))
 515       .Times(mailbox_buffers);
 516   base::RunLoop().RunUntilIdle();
 517   for (size_t i = 0; i < mailbox_syncpoints.size(); ++i) {
 518     // See: MockVideoCaptureControllerEventHandler::OnMailboxBufferReady()
 519     ASSERT_EQ(1u, release_syncpoint_vectors[i].size());
 520     ASSERT_EQ(mailbox_syncpoints[i], ~release_syncpoint_vectors[i][0]);
 521   }
 522   Mock::VerifyAndClearExpectations(client_b_.get());
 523 }
 524
 525 // Exercises the OnError() codepath of VideoCaptureController, and tests the
 526 // behavior of various operations after the error state has been signalled.
 527 TEST_F(VideoCaptureControllerTest, ErrorBeforeDeviceCreation) {
 528   media::VideoCaptureParams session_100;
 529   session_100.requested_format = media::VideoCaptureFormat(
 530       gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 531
 532   media::VideoCaptureParams session_200 = session_100;
 533
 534   const gfx::Size capture_resolution(320, 240);
 535
 536   const VideoCaptureControllerID route_id(0x99);
 537
 538   // Start with one client.
 539   controller_->AddClient(
 540       route_id, client_a_.get(), base::kNullProcessHandle, 100, session_100);
 541   device_->OnError("Test Error");
 542   EXPECT_CALL(*client_a_, DoError(route_id)).Times(1);
 543   base::RunLoop().RunUntilIdle();
 544   Mock::VerifyAndClearExpectations(client_a_.get());
 545
 546   // Second client connects after the error state. It also should get told of
 547   // the error.
 548   EXPECT_CALL(*client_b_, DoError(route_id)).Times(1);
 549   controller_->AddClient(
 550       route_id, client_b_.get(), base::kNullProcessHandle, 200, session_200);
 551   base::RunLoop().RunUntilIdle();
 552   Mock::VerifyAndClearExpectations(client_b_.get());
 553
 554   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer =
 555       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
 556   ASSERT_TRUE(buffer);
 557
 558   device_->OnIncomingCapturedVideoFrame(
 559       buffer,
 560       media::VideoCaptureFormat(
 561           capture_resolution, 30, media::PIXEL_FORMAT_I420),
 562       WrapI420Buffer(buffer, capture_resolution),
 563       base::TimeTicks());
 564   buffer = NULL;
 565
 566   base::RunLoop().RunUntilIdle();
 567 }
 568
 569 // Exercises the OnError() codepath of VideoCaptureController, and tests the
 570 // behavior of various operations after the error state has been signalled.
 571 TEST_F(VideoCaptureControllerTest, ErrorAfterDeviceCreation) {
 572   media::VideoCaptureParams session_100;
 573   session_100.requested_format = media::VideoCaptureFormat(
 574       gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 575
 576   media::VideoCaptureParams session_200 = session_100;
 577
 578   const VideoCaptureControllerID route_id(0x99);
 579
 580   // Start with one client.
 581   controller_->AddClient(
 582       route_id, client_a_.get(), base::kNullProcessHandle, 100, session_100);
 583   media::VideoCaptureFormat device_format(
 584       gfx::Size(10, 10), 25, media::PIXEL_FORMAT_ARGB);
 585
 586   // Start the device. Then, before the first buffer, signal an error and
 587   // deliver the buffer. The error should be propagated to clients; the buffer
 588   // should not be.
 589   base::RunLoop().RunUntilIdle();
 590   Mock::VerifyAndClearExpectations(client_a_.get());
 591
 592   const gfx::Size dims(320, 240);
 593   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer =
 594       device_->ReserveOutputBuffer(media::VideoFrame::I420, dims);
 595   ASSERT_TRUE(buffer);
 596
 597   device_->OnError("Test error");
 598   device_->OnIncomingCapturedVideoFrame(
 599       buffer,
 600       media::VideoCaptureFormat(
 601           dims, device_format.frame_rate, media::PIXEL_FORMAT_I420),
 602       WrapI420Buffer(buffer, dims),
 603       base::TimeTicks());
 604   buffer = NULL;
 605
 606   EXPECT_CALL(*client_a_, DoError(route_id)).Times(1);
 607   base::RunLoop().RunUntilIdle();
 608   Mock::VerifyAndClearExpectations(client_a_.get());
 609
 610   // Second client connects after the error state. It also should get told of
 611   // the error.
 612   EXPECT_CALL(*client_b_, DoError(route_id)).Times(1);
 613   controller_->AddClient(
 614       route_id, client_b_.get(), base::kNullProcessHandle, 200, session_200);
 615   Mock::VerifyAndClearExpectations(client_b_.get());
 616 }
 617
 618 }  // namespace content