Remove dead code paths around PIXEL_STORAGE_TEXTURE in capture pipeline.

content/renderer/media/video_capture_impl_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 "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 15 matching lines @@
   // Filter implementation.
   MOCK_METHOD1(Send, bool(IPC::Message* message));
 
  protected:
   virtual ~MockVideoCaptureMessageFilter() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureMessageFilter);
 };
 
-struct BufferReceivedTestArg {
-  BufferReceivedTestArg(media::VideoPixelFormat pixel_format,
-                        const gpu::MailboxHolder& holder)
-      : pixel_format(pixel_format), mailbox_holder(holder) {}
-
-  BufferReceivedTestArg(media::VideoPixelFormat pixel_format)
-      : pixel_format(pixel_format) {}
-
-  media::VideoPixelFormat pixel_format;
-  gpu::MailboxHolder mailbox_holder;
-};
-
-static const BufferReceivedTestArg kBufferFormats[] = {
-    BufferReceivedTestArg(media::PIXEL_FORMAT_I420),
-    BufferReceivedTestArg(
-        media::PIXEL_FORMAT_ARGB,
-        gpu::MailboxHolder(gpu::Mailbox::Generate(), gpu::SyncToken(), 0))};
-
-class VideoCaptureImplTest
-    : public ::testing::TestWithParam<BufferReceivedTestArg> {
+class VideoCaptureImplTest : public ::testing::Test {
  public:
   class MockVideoCaptureImpl : public VideoCaptureImpl {
    public:
     MockVideoCaptureImpl(const media::VideoCaptureSessionId id,
                          VideoCaptureMessageFilter* filter)
         : VideoCaptureImpl(id, filter), received_buffer_count_(0) {}
     ~MockVideoCaptureImpl() override {}
 
     // Override Send() to mimic device to send events.
     void Send(IPC::Message* message) override {
@@ skipping 110 matching lines @@
   void StopCapture(int client_id) {
     video_capture_impl_->StopCapture(client_id);
   }
 
   void NewBuffer(int buffer_id, const base::SharedMemory& shm) {
     video_capture_impl_->OnBufferCreated(
         base::SharedMemory::DuplicateHandle(shm.handle()),
         shm.mapped_size(), buffer_id);
   }
 
-  void BufferReceived(int buffer_id, const gfx::Size& size,
-                      media::VideoPixelFormat pixel_format,
-                      const gpu::MailboxHolder& mailbox_holder) {
-    const media::VideoFrame::StorageType storage_type =
-        pixel_format != media::PIXEL_FORMAT_ARGB
-            ? media::VideoFrame::STORAGE_UNOWNED_MEMORY
-            : media::VideoFrame::STORAGE_OPAQUE;
+  void BufferReceived(int buffer_id, const gfx::Size& size) {
     video_capture_impl_->OnBufferReceived(
         buffer_id, base::TimeTicks::Now(), base::DictionaryValue(),
-        pixel_format, storage_type, size, gfx::Rect(size), mailbox_holder);
+        media::PIXEL_FORMAT_I420, media::VideoFrame::STORAGE_SHMEM, size,
+        gfx::Rect(size));
   }
 
   void BufferDestroyed(int buffer_id) {
     video_capture_impl_->OnBufferDestroyed(buffer_id);
   }
 
   void DeInit() {
     video_capture_impl_->DeInit();
   }
 
@@ skipping 96 matching lines @@
 // Check that a request to GetDeviceFormatsInUse() ends up eventually in the
 // provided callback.
 TEST_F(VideoCaptureImplTest, GetDeviceFormatsInUse) {
   EXPECT_CALL(*this, OnDeviceFormatsInUse(_));
 
   Init();
   GetDeviceFormatsInUse();
   DeInit();
 }
 
-TEST_P(VideoCaptureImplTest, BufferReceivedWithFormat) {
+TEST_F(VideoCaptureImplTest, BufferReceived) {
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED)).Times(1);
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED)).Times(1);
   EXPECT_CALL(*this, OnFrameReady(_, _)).Times(1);
 
-  const BufferReceivedTestArg& buffer_arg = GetParam();
   const gfx::Size size(1280, 720);
 
   // Create a fake shared memory for buffer.
   base::SharedMemory shm;
   const size_t frame_size = media::VideoFrame::AllocationSize(
-      buffer_arg.pixel_format, size);
+      media::PIXEL_FORMAT_I420, size);
   ASSERT_TRUE(shm.CreateAndMapAnonymous(frame_size));
 
   media::VideoCaptureParams params;
   params.requested_format = media::VideoCaptureFormat(
-      size, 30, buffer_arg.pixel_format);
+      size, 30, media::PIXEL_FORMAT_I420);
 
   Init();
   StartCapture(0, params);
   NewBuffer(0, shm);
-  BufferReceived(0, size, buffer_arg.pixel_format, buffer_arg.mailbox_holder);
+  BufferReceived(0, size);
   StopCapture(0);
   BufferDestroyed(0);
   DeInit();
 }
 
-INSTANTIATE_TEST_CASE_P(I420AndARGB,
-                        VideoCaptureImplTest,
-                        testing::ValuesIn(kBufferFormats));
-
 TEST_F(VideoCaptureImplTest, BufferReceivedAfterStop) {
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED)).Times(1);
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED)).Times(1);
   EXPECT_CALL(*this, OnFrameReady(_, _)).Times(0);
 
   // Create a fake shared memory for buffer.
   base::SharedMemory shm;
   const size_t i420_frame_size = media::VideoFrame::AllocationSize(
       media::PIXEL_FORMAT_I420, params_large_.requested_format.frame_size);
   ASSERT_TRUE(shm.CreateAndMapAnonymous(i420_frame_size));
 
   Init();
   StartCapture(0, params_large_);
   NewBuffer(0, shm);
   StopCapture(0);
-  BufferReceived(0, params_large_.requested_format.frame_size,
-                 media::PIXEL_FORMAT_I420, gpu::MailboxHolder());
+  BufferReceived(0, params_large_.requested_format.frame_size);
   BufferDestroyed(0);
   DeInit();
 
   EXPECT_EQ(this->video_capture_impl_->received_buffer_count(), 1);
 }
 
 TEST_F(VideoCaptureImplTest, AlreadyStarted) {
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STARTED)).Times(2);
   EXPECT_CALL(*this, OnStateUpdate(VIDEO_CAPTURE_STATE_STOPPED)).Times(2);
 
@@ skipping 29 matching lines @@
    StartCapture(0, params_small_);
 
    // Receive state change message from browser.
    video_capture_impl_->ReceiveStateChangeMessage(VIDEO_CAPTURE_STATE_ERROR);
 
    StopCapture(0);
    DeInit();
 }
 
 }  // namespace content