removed AndroidOverlayFactory

media/gpu/android_video_decode_accelerator_unittest.cc

 // Copyright (c) 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 "media/gpu/android_video_decode_accelerator.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 216 matching lines @@
 
   base::WeakPtr<AVDACodecAllocatorClient> client_;
   scoped_refptr<CodecConfig> config_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeCodecAllocator);
 };
 
 // Surface chooser that calls mocked functions to allow counting calls, but
 // also records arguments.  Note that gmock can't mock out unique_ptrs
 // anyway, so we can't mock AndroidVideoSurfaceChooser directly.
-class FakeOverlayHelper : public NiceMock<AndroidVideoSurfaceChooser> {
+class FakeOverlayChooser : public NiceMock<AndroidVideoSurfaceChooser> {
  public:
-  FakeOverlayHelper() : weak_factory_(this) {}
+  FakeOverlayChooser() : weak_factory_(this) {}
 
   // These are called by the real functions.  You may set expectations on
   // them if you like.
   MOCK_METHOD0(MockInitialize, void());
   MOCK_METHOD0(MockReplaceOverlayFactory, void());
 
   // We guarantee that we'll only clear this during destruction, so that you
   // may treat it as "pointer that lasts as long as |this| does".
-  base::WeakPtr<FakeOverlayHelper> GetWeakPtrForTesting() {
+  base::WeakPtr<FakeOverlayChooser> GetWeakPtrForTesting() {
     return weak_factory_.GetWeakPtr();
   }
 
-  void Initialize(
-      UseOverlayCB use_overlay_cb,
-      UseSurfaceTextureCB use_surface_texture_cb,
-      StopUsingOverlayImmediatelyCB stop_immediately_cb,
-      std::unique_ptr<AndroidOverlayFactory> initial_factory) override {
+  void Initialize(UseOverlayCB use_overlay_cb,
+                  UseSurfaceTextureCB use_surface_texture_cb,
+                  StopUsingOverlayImmediatelyCB stop_immediately_cb,
+                  AndroidOverlayFactoryCB initial_factory) override {
     MockInitialize();
 
     factory_ = std::move(initial_factory);
     use_overlay_cb_ = std::move(use_overlay_cb);
     use_surface_texture_cb_ = std::move(use_surface_texture_cb);
     stop_immediately_cb_ = std::move(stop_immediately_cb);
   }
 
-  void ReplaceOverlayFactory(
-      std::unique_ptr<AndroidOverlayFactory> factory) override {
+  void ReplaceOverlayFactory(AndroidOverlayFactoryCB factory) override {
     MockReplaceOverlayFactory();
     factory_ = std::move(factory);
   }
 
   // Notify AVDA to use a surface texture.
   void ProvideSurfaceTexture() {
     use_surface_texture_cb_.Run();
     base::RunLoop().RunUntilIdle();
   }
 
   void ProvideOverlay(std::unique_ptr<AndroidOverlay> overlay) {
     use_overlay_cb_.Run(std::move(overlay));
     base::RunLoop().RunUntilIdle();
   }
 
   void StopImmediately(AndroidOverlay* overlay) {
     stop_immediately_cb_.Run(overlay);
     base::RunLoop().RunUntilIdle();
   }
 
   UseOverlayCB use_overlay_cb_;
   UseSurfaceTextureCB use_surface_texture_cb_;
   StopUsingOverlayImmediatelyCB stop_immediately_cb_;
 
-  std::unique_ptr<AndroidOverlayFactory> factory_;
+  AndroidOverlayFactoryCB factory_;
 
-  base::WeakPtrFactory<FakeOverlayHelper> weak_factory_;
+  base::WeakPtrFactory<FakeOverlayChooser> weak_factory_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FakeOverlayHelper);
+  DISALLOW_COPY_AND_ASSIGN(FakeOverlayChooser);
 };
 
 }  // namespace
 
 class AndroidVideoDecodeAcceleratorTest : public testing::Test {
  public:
   // We pick this profile since it's always supported.
   AndroidVideoDecodeAcceleratorTest() : config_(H264PROFILE_BASELINE) {}
 
   ~AndroidVideoDecodeAcceleratorTest() override {}
 
   void SetUp() override {
     JNIEnv* env = base::android::AttachCurrentThread();
     RegisterJni(env);
 
     main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
     gl::init::ShutdownGL();
     ASSERT_TRUE(gl::init::InitializeGLOneOff());
     surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size(16, 16));
     context_ = gl::init::CreateGLContext(nullptr, surface_.get(),
                                          gl::GLContextAttribs());
     context_->MakeCurrent(surface_.get());
 
-    chooser_that_is_usually_null_ = base::MakeUnique<FakeOverlayHelper>();
+    chooser_that_is_usually_null_ = base::MakeUnique<FakeOverlayChooser>();
     chooser_ = chooser_that_is_usually_null_->GetWeakPtrForTesting();
 
     platform_config_.sdk_int = base::android::SDK_VERSION_MARSHMALLOW;
     platform_config_.allow_setsurface = true;
     platform_config_.force_deferred_surface_creation = false;
 
     // By default, allow deferred init.
     config_.is_deferred_initialization_allowed = true;
   }
 
@@ skipping 11 matching lines @@
     base::RunLoop().RunUntilIdle();
     return result;
   }
 
   // Initialize |vda_|, providing a new surface for it.  You may get the surface
   // by asking |codec_allocator_|.
   void InitializeAVDAWithOverlay() {
     config_.surface_id = 123;
     ASSERT_TRUE(InitializeAVDA());
     base::RunLoop().RunUntilIdle();
-    ASSERT_TRUE(chooser_->factory_ != nullptr);
+    ASSERT_TRUE(chooser_->factory_);
 
     // Have the factory provide an overlay, and verify that codec creation is
     // provided with that overlay.
     std::unique_ptr<MockAndroidOverlay> overlay =
         base::MakeUnique<MockAndroidOverlay>();
     // Set the expectations first, since ProvideOverlay might cause callbacks.
     EXPECT_CALL(codec_allocator_,
                 MockCreateMediaCodecAsync(overlay.get(), nullptr));
     chooser_->ProvideOverlay(std::move(overlay));
 
     // Provide the codec so that we can check if it's freed properly.
     EXPECT_CALL(client_, NotifyInitializationComplete(true));
     codec_allocator_.ProvideMockCodecAsync();
     base::RunLoop().RunUntilIdle();
   }
 
   void InitializeAVDAWithSurfaceTexture() {
     ASSERT_TRUE(InitializeAVDA());
     base::RunLoop().RunUntilIdle();
     // We do not expect a factory, since we are using SurfaceTexture.
-    ASSERT_TRUE(chooser_->factory_ == nullptr);
+    ASSERT_FALSE(chooser_->factory_);
 
     // Set the expectations first, since ProvideOverlay might cause callbacks.
     EXPECT_CALL(codec_allocator_,
                 MockCreateMediaCodecAsync(nullptr, NotNull()));
     chooser_->ProvideSurfaceTexture();
 
     // Provide the codec so that we can check if it's freed properly.
     EXPECT_CALL(client_, NotifyInitializationComplete(true));
     codec_allocator_.ProvideMockCodecAsync();
     base::RunLoop().RunUntilIdle();
@@ skipping 21 matching lines @@
   scoped_refptr<gl::GLContext> context_;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   NiceMock<gpu::gles2::MockGLES2Decoder> gl_decoder_;
   NiceMock<MockVDAClient> client_;
   FakeCodecAllocator codec_allocator_;
   VideoDecodeAccelerator::Config config_;
 
   AndroidVideoDecodeAccelerator::PlatformConfig platform_config_;
 
   // We maintain a weak ref to this since AVDA owns it.
-  base::WeakPtr<FakeOverlayHelper> chooser_;
+  base::WeakPtr<FakeOverlayChooser> chooser_;
 
   // This must be a unique pointer to a VDA, not an AVDA, to ensure the
   // the default_delete specialization that calls Destroy() will be used.
   std::unique_ptr<VideoDecodeAccelerator> vda_;
 
   AndroidVideoDecodeAccelerator* avda() {
     return reinterpret_cast<AndroidVideoDecodeAccelerator*>(vda_.get());
   }
 
  private:
   // This is the object that |chooser_| points to, or nullptr once we assign
   // ownership to AVDA.
-  std::unique_ptr<FakeOverlayHelper> chooser_that_is_usually_null_;
+  std::unique_ptr<FakeOverlayChooser> chooser_that_is_usually_null_;
 };
 
 TEST_F(AndroidVideoDecodeAcceleratorTest, ConfigureUnsupportedCodec) {
   SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
 
   config_ = VideoDecodeAccelerator::Config(VIDEO_CODEC_PROFILE_UNKNOWN);
   ASSERT_FALSE(InitializeAVDA());
 }
 
 TEST_F(AndroidVideoDecodeAcceleratorTest,
@@ skipping 250 matching lines @@
   InitializeAVDAWithSurfaceTexture();
 
   // This should do nothing.
   EXPECT_CALL(*codec_allocator_.most_recent_codec(), SetSurface(_)).Times(0);
   chooser_->ProvideSurfaceTexture();
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media