Remove dead code paths around PIXEL_STORAGE_TEXTURE in capture pipeline.

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"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
-#include "content/common/gpu/client/gl_helper.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/test/test_browser_thread_bundle.h"
-#include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if !defined(OS_ANDROID)
-#include "content/browser/compositor/test/no_transport_image_transport_factory.h"
-#endif
-
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::SaveArg;
 
 namespace content {
 
 class MockVideoCaptureControllerEventHandler
     : public VideoCaptureControllerEventHandler {
  public:
   explicit MockVideoCaptureControllerEventHandler(
       VideoCaptureController* controller)
       : controller_(controller),
         resource_utilization_(-1.0) {}
   ~MockVideoCaptureControllerEventHandler() override {}
 
   // These mock methods are delegated to by our fake implementation of
   // VideoCaptureControllerEventHandler, to be used in EXPECT_CALL().
   MOCK_METHOD1(DoBufferCreated, void(VideoCaptureControllerID));
   MOCK_METHOD1(DoBufferCreated2, void(VideoCaptureControllerID));
   MOCK_METHOD1(DoBufferDestroyed, void(VideoCaptureControllerID));
   MOCK_METHOD2(DoI420BufferReady,
                void(VideoCaptureControllerID, const gfx::Size&));
-  MOCK_METHOD2(DoTextureBufferReady,
-               void(VideoCaptureControllerID, const gfx::Size&));
   MOCK_METHOD1(DoEnded, void(VideoCaptureControllerID));
   MOCK_METHOD1(DoError, void(VideoCaptureControllerID));
 
   void OnError(VideoCaptureControllerID id) override {
     DoError(id);
   }
   void OnBufferCreated(VideoCaptureControllerID id,
                        base::SharedMemoryHandle handle,
                        int length, int buffer_id) override {
     DoBufferCreated(id);
   }
   void OnBufferCreated2(
       VideoCaptureControllerID id,
       const std::vector<gfx::GpuMemoryBufferHandle>& handles,
       const gfx::Size& size,
       int buffer_id) override {
     DoBufferCreated2(id);
   }
   void OnBufferDestroyed(VideoCaptureControllerID id, int buffer_id) override {
     DoBufferDestroyed(id);
   }
   void OnBufferReady(VideoCaptureControllerID id,
                      int buffer_id,
                      const scoped_refptr<media::VideoFrame>& frame,
                      const base::TimeTicks& timestamp) override {
-    if (!frame->HasTextures()) {
       EXPECT_EQ(frame->format(), media::PIXEL_FORMAT_I420);
       DoI420BufferReady(id, frame->coded_size());
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&VideoCaptureController::ReturnBuffer,
                      base::Unretained(controller_), id, this, buffer_id,
                      gpu::SyncToken(), resource_utilization_));
-    } else {
-      EXPECT_EQ(frame->format(), media::PIXEL_FORMAT_ARGB);
-      DoTextureBufferReady(id, frame->coded_size());
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&VideoCaptureController::ReturnBuffer,
-                                base::Unretained(controller_), id, this,
-                                buffer_id, frame->mailbox_holder(0).sync_token,
-                                resource_utilization_));
-    }
   }
   void OnEnded(VideoCaptureControllerID id) override {
     DoEnded(id);
     // OnEnded() must respond by (eventually) unregistering the client.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&VideoCaptureController::RemoveClient),
                    base::Unretained(controller_), id, this));
   }
 
@@ skipping 16 matching lines @@
     client_a_.reset(new MockVideoCaptureControllerEventHandler(
         controller_.get()));
     client_b_.reset(new MockVideoCaptureControllerEventHandler(
         controller_.get()));
   }
 
   void TearDown() override { base::RunLoop().RunUntilIdle(); }
 
   scoped_refptr<media::VideoFrame> WrapI420Buffer(gfx::Size dimensions,
                                                   uint8* data) {
-    return media::VideoFrame::WrapExternalData(
+    return media::VideoFrame::WrapExternalSharedMemory(
         media::PIXEL_FORMAT_I420, dimensions, gfx::Rect(dimensions), dimensions,
         data,
         media::VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420, dimensions),
-        base::TimeDelta());
-  }
-
-  scoped_refptr<media::VideoFrame> WrapMailboxBuffer(
-      const gpu::MailboxHolder& holder,
-      const media::VideoFrame::ReleaseMailboxCB& release_cb,
-      gfx::Size dimensions) {
-    return media::VideoFrame::WrapNativeTexture(
-        media::PIXEL_FORMAT_ARGB, holder, release_cb, dimensions,
-        gfx::Rect(dimensions), dimensions, base::TimeDelta());
+        base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
   }
 
   TestBrowserThreadBundle bundle_;
   scoped_ptr<MockVideoCaptureControllerEventHandler> client_a_;
   scoped_ptr<MockVideoCaptureControllerEventHandler> client_b_;
   scoped_ptr<VideoCaptureController> controller_;
   scoped_ptr<media::VideoCaptureDevice::Client> device_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureControllerTest);
@@ skipping 92 matching lines @@
   ASSERT_EQ(1, controller_->GetClientCount())
       << "Removing non-existant session 200 should be a no-op.";
   ASSERT_EQ(400,
       controller_->RemoveClient(client_b_route_2, client_b_.get()))
       << "Removing client B/2 should return its session_id.";
   // Clients in controller: []
   ASSERT_EQ(0, controller_->GetClientCount())
       << "Client count should return to zero after all clients are gone.";
 }
 
-static void CacheSyncToken(gpu::SyncToken* called_release_sync_token,
-                           const gpu::SyncToken& release_sync_token) {
-  *called_release_sync_token = release_sync_token;
-}
-
 // 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) {
-// VideoCaptureController::ReturnBuffer() uses ImageTransportFactory.
-#if !defined(OS_ANDROID)
-  ImageTransportFactory::InitializeForUnitTests(
-      scoped_ptr<ImageTransportFactory>(new NoTransportImageTransportFactory));
-#endif
-
   media::VideoCaptureParams session_100;
   session_100.requested_format = media::VideoCaptureFormat(
       gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 
   media::VideoCaptureParams session_200 = session_100;
 
   media::VideoCaptureParams session_300 = session_100;
 
   media::VideoCaptureParams session_1 = session_100;
 
@@ skipping 204 matching lines @@
   device_->OnIncomingCapturedVideoFrame(buffer4.Pass(), video_frame,
                                         base::TimeTicks());
   // B2 is the only client left, and is the only one that should
   // get the buffer.
   EXPECT_CALL(*client_b_,
               DoI420BufferReady(client_b_route_2, capture_resolution))
       .Times(2);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
-
-  // Allocate all buffers from the buffer pool, half as SHM buffer and half as
-  // mailbox buffers.  Make sure of different counts though.
-#if defined(OS_ANDROID)
-  int mailbox_buffers = 0;
-#else
-  int mailbox_buffers = kPoolSize / 2;
-#endif
-  int shm_buffers = kPoolSize - mailbox_buffers;
-  if (shm_buffers == mailbox_buffers) {
-    shm_buffers--;
-    mailbox_buffers++;
-  }
-
-  for (int i = 0; i < shm_buffers; ++i) {
-    scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer =
-        device_->ReserveOutputBuffer(capture_resolution,
-                                     media::PIXEL_FORMAT_I420,
-                                     media::PIXEL_STORAGE_CPU);
-    ASSERT_TRUE(buffer.get());
-    video_frame =
-        WrapI420Buffer(capture_resolution, static_cast<uint8*>(buffer->data()));
-    device_->OnIncomingCapturedVideoFrame(buffer.Pass(), video_frame,
-                                          base::TimeTicks());
-  }
-  std::vector<gpu::SyncToken> mailbox_synctokens(mailbox_buffers);
-  std::vector<gpu::SyncToken> release_synctokens(mailbox_buffers);
-  for (int i = 0; i < mailbox_buffers; ++i) {
-    scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer =
-        device_->ReserveOutputBuffer(capture_resolution,
-                                     media::PIXEL_FORMAT_ARGB,
-                                     media::PIXEL_STORAGE_TEXTURE);
-    ASSERT_TRUE(buffer.get());
-#if !defined(OS_ANDROID)
-    ImageTransportFactory::GetInstance()->GetGLHelper()->GenerateSyncToken(
-        &mailbox_synctokens[i]);
-#endif
-    device_->OnIncomingCapturedVideoFrame(
-        buffer.Pass(),
-        WrapMailboxBuffer(gpu::MailboxHolder(gpu::Mailbox::Generate(),
-                                             mailbox_synctokens[i], 0),
-                          base::Bind(&CacheSyncToken, &release_synctokens[i]),
-                          capture_resolution),
-        base::TimeTicks());
-  }
-  // ReserveOutputBuffers ought to fail now regardless of buffer format, because
-  // the pool is depleted.
-  ASSERT_FALSE(
-      device_->ReserveOutputBuffer(capture_resolution,
-                                   media::PIXEL_FORMAT_I420,
-                                   media::PIXEL_STORAGE_CPU).get());
-  ASSERT_FALSE(
-      device_->ReserveOutputBuffer(capture_resolution,
-                                   media::PIXEL_FORMAT_ARGB,
-                                   media::PIXEL_STORAGE_TEXTURE).get());
-  EXPECT_CALL(*client_b_,
-              DoI420BufferReady(client_b_route_2, capture_resolution))
-      .Times(shm_buffers);
-  EXPECT_CALL(*client_b_,
-              DoTextureBufferReady(client_b_route_2, capture_resolution))
-      .Times(mailbox_buffers);
-#if !defined(OS_ANDROID)
-  EXPECT_CALL(*client_b_, DoBufferDestroyed(client_b_route_2));
-#endif
-  base::RunLoop().RunUntilIdle();
-  for (size_t i = 0; i < mailbox_synctokens.size(); ++i) {
-    // A new release sync point must be inserted when the video frame is
-    // returned to the Browser process.
-    // See: MockVideoCaptureControllerEventHandler::OnMailboxBufferReady() and
-    // VideoCaptureController::ReturnBuffer()
-    ASSERT_NE(mailbox_synctokens[i], release_synctokens[i]);
-  }
-  Mock::VerifyAndClearExpectations(client_b_.get());
-
-#if !defined(OS_ANDROID)
-  ImageTransportFactory::Terminate();
-#endif
 }
 
 // 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.requested_format = media::VideoCaptureFormat(
       gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 
   media::VideoCaptureParams session_200 = session_100;
@@ skipping 72 matching lines @@
 
   // 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);
   Mock::VerifyAndClearExpectations(client_b_.get());
 }
 
 }  // namespace content