Consolidate duplicated frame / capability structures in video_capture_types.h

content/browser/renderer_host/media/web_contents_video_capture_device_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.
 
 #include "content/browser/renderer_host/media/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/debug/debugger.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 387 matching lines @@
       base::AutoLock guard(lock_);
       error_encountered_ = true;
     }
     PostColorOrError(kNothingYet);
   }
 
   virtual void OnFrameInfo(const media::VideoCaptureCapability& info) OVERRIDE {
     EXPECT_EQ(kTestWidth, info.width);
     EXPECT_EQ(kTestHeight, info.height);
     EXPECT_EQ(kTestFramesPerSecond, info.frame_rate);
-    EXPECT_EQ(media::VideoCaptureCapability::kI420, info.color);
+    EXPECT_EQ(media::kI420, info.color);
   }
 
  private:
   base::Lock lock_;
   bool error_encountered_;
   SkColor wait_color_yuv_;
   scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
 
   DISALLOW_COPY_AND_ASSIGN(StubConsumer);
 };
@@ skipping 119 matching lines @@
 TEST_F(WebContentsVideoCaptureDeviceTest, InvalidInitialWebContentsError) {
   // Before the installs itself on the UI thread up to start capturing, we'll
   // delete the web contents. This should trigger an error which can happen in
   // practice; we should be able to recover gracefully.
   ResetWebContents();
 
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
   device()->Start();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForError());
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, WebContentsDestroyed) {
   // We'll simulate the tab being closed after the capture pipeline is up and
   // running.
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
   device()->Start();
 
   // Do one capture to prove
   source()->SetSolidColor(SK_ColorRED);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
 
   base::RunLoop().RunUntilIdle();
 
   // Post a task to close the tab. We should see an error reported to the
   // consumer.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&WebContentsVideoCaptureDeviceTest::ResetWebContents,
                  base::Unretained(this)));
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForError());
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest,
        StopDeviceBeforeCaptureMachineCreation) {
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
   device()->Start();
   // Make a point of not running the UI messageloop here.
   device()->Stop();
   device()->DeAllocate();
   DestroyVideoCaptureDevice();
 
   // Currently, there should be CreateCaptureMachineOnUIThread() and
   // DestroyCaptureMachineOnUIThread() tasks pending on the current (UI) message
   // loop. These should both succeed without crashing, and the machine should
   // wind up in the idle state.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, StopWithRendererWorkToDo) {
   // Set up the test to use RGB copies and an normal
   source()->SetCanCopyToVideoFrame(false);
   source()->SetUseFrameSubscriber(false);
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
 
   device()->Start();
   // Make a point of not running the UI messageloop here.
   // TODO(ajwong): Why do we care?
   base::RunLoop().RunUntilIdle();
 
   for (int i = 0; i < 10; ++i)
     SimulateDrawEvent();
 
   device()->Stop();
   device()->DeAllocate();
   // Currently, there should be CreateCaptureMachineOnUIThread() and
   // DestroyCaptureMachineOnUIThread() tasks pending on the current message
   // loop. These should both succeed without crashing, and the machine should
   // wind up in the idle state.
   ASSERT_FALSE(consumer()->HasError());
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(consumer()->HasError());
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, DeviceRestart) {
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
   device()->Start();
   base::RunLoop().RunUntilIdle();
   source()->SetSolidColor(SK_ColorRED);
   SimulateDrawEvent();
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
@@ skipping 21 matching lines @@
 
 // The "happy case" test.  No scaling is needed, so we should be able to change
 // the picture emitted from the source and expect to see each delivered to the
 // consumer. The test will alternate between the three capture paths, simulating
 // falling in and out of accelerated compositing.
 TEST_F(WebContentsVideoCaptureDeviceTest, GoesThroughAllTheMotions) {
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
 
   device()->Start();
 
   for (int i = 0; i < 6; i++) {
     const char* name = NULL;
     switch (i % 3) {
@@ skipping 35 matching lines @@
     ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorBLACK));
   }
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, RejectsInvalidAllocateParams) {
   media::VideoCaptureCapability capture_format(
       1280,
       720,
       -2,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&media::VideoCaptureDevice::Allocate,
                                      base::Unretained(device()),
                                      capture_format,
                                      consumer()));
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForError());
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, BadFramesGoodFrames) {
   media::VideoCaptureCapability capture_format(
       kTestWidth,
       kTestHeight,
       kTestFramesPerSecond,
-      media::VideoCaptureCapability::kI420,
+      media::kI420,
       0,
       false,
       media::ConstantResolutionVideoCaptureDevice);
   device()->Allocate(capture_format, consumer());
 
   // 1x1 is too small to process; we intend for this to result in an error.
   source()->SetCopyResultSize(1, 1);
   source()->SetSolidColor(SK_ColorRED);
   device()->Start();
 
@@ skipping 11 matching lines @@
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorGREEN));
   source()->SetSolidColor(SK_ColorRED);
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
 
   device()->Stop();
   device()->DeAllocate();
 }
 
 }  // namespace
 }  // namespace content