Add multiple destruction callbacks to AndroidOverlay.

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 233 matching lines @@
   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<FakeOverlayChooser> GetWeakPtrForTesting() {
     return weak_factory_.GetWeakPtr();
   }
 
   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(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_;
 
   AndroidOverlayFactoryCB factory_;
 
   base::WeakPtrFactory<FakeOverlayChooser> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeOverlayChooser);
 };
 
 }  // namespace
@@ skipping 49 matching lines @@
   void InitializeAVDAWithOverlay() {
     config_.surface_id = 123;
     ASSERT_TRUE(InitializeAVDA());
     base::RunLoop().RunUntilIdle();
     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>();
+    overlay_callbacks_ = overlay->GetCallbacks();
+
     // 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();
   }
@@ skipping 36 matching lines @@
   scoped_refptr<gl::GLSurface> surface_;
   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_;
 
+  // Set by InitializeAVDAWithOverlay()
+  MockAndroidOverlay::Callbacks overlay_callbacks_;
+
   // We maintain a weak ref to this since AVDA owns it.
   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());
   }
@@ skipping 124 matching lines @@
   SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
 
   InitializeAVDAWithOverlay();
 
   // It would be nice if we knew that this was a surface texture.  As it is, we
   // just destroy the VDA and expect that we're provided with one.  Hopefully,
   // AVDA is actually calling SetSurface properly.
   EXPECT_CALL(*codec_allocator_.most_recent_codec(), SetSurface(_))
       .WillOnce(Return(true));
   codec_allocator_.codec_destruction_observer()->DestructionIsOptional();
-  chooser_->StopImmediately(codec_allocator_.most_recent_overlay());
+  overlay_callbacks_.SurfaceDestroyed.Run();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(codec_allocator_,
               MockReleaseMediaCodec(codec_allocator_.most_recent_codec(),
                                     nullptr, NotNull()));
   vda_ = nullptr;
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(AndroidVideoDecodeAcceleratorTest, SwitchesToSurfaceTextureEventually) {
   // Provide a surface, and a codec, then request that AVDA switches to a
@@ skipping 96 matching lines @@
   platform_config_.allow_setsurface = false;
   InitializeAVDAWithOverlay();
   EXPECT_CALL(*codec_allocator_.most_recent_codec(), SetSurface(_)).Times(0);
 
   // This should free the codec.
   EXPECT_CALL(
       codec_allocator_,
       MockReleaseMediaCodec(codec_allocator_.most_recent_codec(),
                             codec_allocator_.most_recent_overlay(), nullptr));
   codec_allocator_.codec_destruction_observer()->ExpectDestruction();
-  chooser_->StopImmediately(codec_allocator_.most_recent_overlay());
+  overlay_callbacks_.SurfaceDestroyed.Run();
   base::RunLoop().RunUntilIdle();
 
   // Verify that the codec has been released, since |vda_| will be destroyed
   // soon.  The expectations must be met before that.
   testing::Mock::VerifyAndClearExpectations(&codec_allocator_);
   codec_allocator_.codec_destruction_observer()->DestructionIsOptional();
 }
 
 TEST_F(AndroidVideoDecodeAcceleratorTest,
        MultipleSurfaceTextureCallbacksAreIgnored) {
   // Ask AVDA to switch to ST when it's already using ST, nothing should happen.
   SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
 
   InitializeAVDAWithSurfaceTexture();
 
   // This should do nothing.
   EXPECT_CALL(*codec_allocator_.most_recent_codec(), SetSurface(_)).Times(0);
   chooser_->ProvideSurfaceTexture();
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media