Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/resources/video_resource_updater_unittest.cc

 // Copyright 2013 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 "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
@@ skipping 75 matching lines @@
 
 class VideoResourceUpdaterTest : public testing::Test {
  protected:
   VideoResourceUpdaterTest() {
     std::unique_ptr<WebGraphicsContext3DUploadCounter> context3d(
         new WebGraphicsContext3DUploadCounter());
 
     context3d_ = context3d.get();
     context3d_->set_support_texture_storage(true);
 
-    output_surface3d_ = FakeOutputSurface::Create3d(std::move(context3d));
-    CHECK(output_surface3d_->BindToClient(&client_));
+    context_provider_ = TestContextProvider::Create(std::move(context3d));
+    context_provider_->BindToCurrentThread();
   }
 
   void SetUp() override {
     testing::Test::SetUp();
 
-    output_surface_software_ = FakeOutputSurface::CreateSoftware(
-        base::WrapUnique(new SoftwareOutputDevice));
-    CHECK(output_surface_software_->BindToClient(&client_));
-
     shared_bitmap_manager_.reset(new SharedBitmapManagerAllocationCounter());
     resource_provider3d_ = FakeResourceProvider::Create(
-        output_surface3d_.get(), shared_bitmap_manager_.get());
-
-    resource_provider_software_ = FakeResourceProvider::Create(
-        output_surface_software_.get(), shared_bitmap_manager_.get());
+        context_provider_.get(), shared_bitmap_manager_.get());
+    resource_provider_software_ =
+        FakeResourceProvider::Create(nullptr, shared_bitmap_manager_.get());
   }
 
   scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame() {
     const int kDimension = 10;
     gfx::Size size(kDimension, kDimension);
     static uint8_t y_data[kDimension * kDimension] = {0};
     static uint8_t u_data[kDimension * kDimension / 2] = {0};
     static uint8_t v_data[kDimension * kDimension / 2] = {0};
 
     scoped_refptr<media::VideoFrame> video_frame =
@@ skipping 111 matching lines @@
                                               base::Bind(&ReleaseMailboxCB),
                                               size,             // coded_size
                                               gfx::Rect(size),  // visible_rect
                                               size,             // natural_size
                                               base::TimeDelta());  // timestamp
     EXPECT_TRUE(video_frame);
     return video_frame;
   }
 
   WebGraphicsContext3DUploadCounter* context3d_;
-  FakeOutputSurfaceClient client_;
-  std::unique_ptr<FakeOutputSurface> output_surface3d_;
-  std::unique_ptr<FakeOutputSurface> output_surface_software_;
+  scoped_refptr<TestContextProvider> context_provider_;
   std::unique_ptr<SharedBitmapManagerAllocationCounter> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider3d_;
   std::unique_ptr<ResourceProvider> resource_provider_software_;
 };
 
 TEST_F(VideoResourceUpdaterTest, SoftwareFrame) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, HighBitFrameNoF16) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 class VideoResourceUpdaterTestWithF16 : public VideoResourceUpdaterTest {
  public:
   VideoResourceUpdaterTestWithF16() : VideoResourceUpdaterTest() {
     context3d_->set_support_texture_half_float_linear(true);
   }
 };
 
 TEST_F(VideoResourceUpdaterTestWithF16, HighBitFrame) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, HighBitFrameSoftwareCompositor) {
   VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrame) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrameSoftwareCompositor) {
   VideoResourceUpdater updater(nullptr, resource_provider_software_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
 }
 
 TEST_F(VideoResourceUpdaterTest, ReuseResource) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
   video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
 
   // Allocate the resources for a YUV video frame.
   context3d_->ResetUploadCount();
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
@@ skipping 11 matching lines @@
   context3d_->ResetUploadCount();
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
   EXPECT_EQ(size_t(3), resources.release_callbacks.size());
   // The data should be reused so expect no texture uploads.
   EXPECT_EQ(0, context3d_->UploadCount());
 }
 
 TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDelete) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
   video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
 
   // Allocate the resources for a YUV video frame.
   context3d_->ResetUploadCount();
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
   EXPECT_EQ(size_t(3), resources.mailboxes.size());
@@ skipping 73 matching lines @@
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::SOFTWARE_RESOURCE, resources.type);
   EXPECT_EQ(size_t(0), resources.mailboxes.size());
   EXPECT_EQ(size_t(0), resources.release_callbacks.size());
   EXPECT_EQ(size_t(1), resources.software_resources.size());
   // The data should be reused so expect no new allocations.
   EXPECT_EQ(0, shared_bitmap_manager_->AllocationCount());
 }
 
 TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
 
   scoped_refptr<media::VideoFrame> video_frame =
       CreateTestRGBAHardwareVideoFrame();
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE,
             resources.type);
   EXPECT_EQ(1u, resources.mailboxes.size());
@@ skipping 11 matching lines @@
 
   video_frame = CreateTestYuvHardwareVideoFrame();
   video_frame->metadata()->SetBoolean(
       media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED, true);
 
   resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_TRUE(resources.read_lock_fences_enabled);
 }
 
 TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_StreamTexture) {
-  VideoResourceUpdater updater(output_surface3d_->context_provider(),
+  VideoResourceUpdater updater(context_provider_.get(),
                                resource_provider3d_.get());
   context3d_->ResetTextureCreationCount();
   scoped_refptr<media::VideoFrame> video_frame =
       CreateTestStreamTextureHardwareVideoFrame(false);
 
   VideoFrameExternalResources resources =
       updater.CreateExternalResourcesFromVideoFrame(video_frame);
   EXPECT_EQ(VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE,
             resources.type);
   EXPECT_EQ(1u, resources.mailboxes.size());
@@ skipping 18 matching lines @@
   // The texture copy path requires the use of CopyTextureCHROMIUM, which
   // enforces that the target texture not be immutable, as it may need
   // to alter the storage of the texture. Therefore, this test asserts
   // that an immutable texture wasn't created by glTexStorage2DEXT, when
   // that extension is supported.
   EXPECT_FALSE(context3d_->WasImmutableTextureCreated());
 }
 
 }  // namespace
 }  // namespace cc