Add multiple destruction callbacks to AndroidOverlay.

media/gpu/android_video_surface_chooser_impl_unittest.cc

 // Copyright 2017 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_surface_chooser_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 21 matching lines @@
 
   void UseOverlayImpl(std::unique_ptr<AndroidOverlay> overlay) {
     UseOverlay(overlay.get());
 
     // Also take ownership of the overlay, so that it's not destroyed.
     overlay_ = std::move(overlay);
   }
 
   // Note that this won't clear |overlay_|, which is helpful.
   MOCK_METHOD0(UseSurfaceTexture, void(void));
-  MOCK_METHOD1(StopUsingOverlayImmediately, void(AndroidOverlay*));
 
  private:
   std::unique_ptr<AndroidOverlay> overlay_;
 };
 
 }  // namespace
 
 namespace media {
 
 // Unit tests for AndroidVideoSurfaceChooserImpl
@@ skipping 20 matching lines @@
     // checking expectations.
     // Note that it might already be null.
     destruction_observer_ = nullptr;
   }
 
   // Start the chooser, providing |factory| as the initial factory.
   void StartChooser(AndroidOverlayFactoryCB factory) {
     chooser_->Initialize(
         base::Bind(&MockClient::UseOverlayImpl, base::Unretained(&client_)),
         base::Bind(&MockClient::UseSurfaceTexture, base::Unretained(&client_)),
-        base::Bind(&MockClient::StopUsingOverlayImmediately,
-                   base::Unretained(&client_)),
         std::move(factory));
   }
 
   // AndroidOverlayFactoryCB is a RepeatingCallback, so we can't just bind
   // something that uses unique_ptr.  RepeatingCallback needs to copy it.
   class Factory {
    public:
     Factory(std::unique_ptr<MockAndroidOverlay> overlay,
             base::RepeatingCallback<void()> create_overlay_cb)
         : overlay_(std::move(overlay)),
@@ skipping 98 matching lines @@
   testing::Mock::VerifyAndClearExpectations(this);
 
   // The overlay may be destroyed at any time after we send OverlayFailed.  It
   // doesn't have to be destroyed.  We just care that it hasn't been destroyed
   // before now.
   destruction_observer_ = nullptr;
   EXPECT_CALL(client_, UseSurfaceTexture());
   overlay_callbacks_.OverlayFailed.Run();
 }
 
-TEST_F(AndroidVideoSurfaceChooserImplTest,
-       OnSurfaceDestroyedSendsNotification) {
-  // If |chooser_| is notified about OnSurfaceDestroyed, then |client_| should
-  // also be notified.
-
-  EXPECT_CALL(*this, MockOnOverlayCreated());
-  StartChooser(FactoryFor(std::move(overlay_)));
-  EXPECT_CALL(client_, UseOverlay(NotNull()));
-  overlay_callbacks_.OverlayReady.Run();
-
-  testing::Mock::VerifyAndClearExpectations(&client_);
-  testing::Mock::VerifyAndClearExpectations(this);
-
-  // Switch to a surface texture.  OnSurfaceDestroyed should still be sent.
-  EXPECT_CALL(client_, UseSurfaceTexture());
-  chooser_->ReplaceOverlayFactory(AndroidOverlayFactoryCB());
-  testing::Mock::VerifyAndClearExpectations(&client_);
-
-  EXPECT_CALL(client_, StopUsingOverlayImmediately(NotNull()));
-  overlay_callbacks_.SurfaceDestroyed.Run();
-}
-
-TEST_F(AndroidVideoSurfaceChooserImplTest,
-       OnSurfaceDestroyedSendsNotificationAfterSwitch) {
-  // This tests two things.  First:
-  // If |chooser_| is notified about OnSurfaceDestroyed, then |client_| should
-  // also be notified even if |chooser_| has already told |client_| to
-  // transition to SurfaceTexture.  It has no idea if |client_| has actually
-  // transitioned, so it has to notify it to stop immediately, in case it
-  // hasn't. Second: |chooser_| should notify |client_| to switch to surface
-  // texture if it provided an overlay, and the factory is changed.  This
-  // indicates that whoever provided the factory is revoking it, so we shouldn't
-  // be using overlays from that factory anymore. We specifically test overlay
-  // => no factory, since |chooser_| could elide multiple calls to switch to
-  // surface texture.
-  //
-  // We test these together, since switching the factory is the only way we have
-  // to make |chooser_| transition to SurfaceTexture without sending destroyed.
-
-  EXPECT_CALL(*this, MockOnOverlayCreated());
-  StartChooser(FactoryFor(std::move(overlay_)));
-  EXPECT_CALL(client_, UseOverlay(NotNull()));
-  overlay_callbacks_.OverlayReady.Run();
-
-  testing::Mock::VerifyAndClearExpectations(&client_);
-  testing::Mock::VerifyAndClearExpectations(this);
-
-  // Switch factories, to notify the client back to switch to SurfaceTexture.
-  EXPECT_CALL(client_, UseSurfaceTexture());
-  chooser_->ReplaceOverlayFactory(AndroidOverlayFactoryCB());
-  testing::Mock::VerifyAndClearExpectations(&client_);
-
-  // Destroy the original surface.
-  EXPECT_CALL(client_, StopUsingOverlayImmediately(NotNull()));
-  overlay_callbacks_.SurfaceDestroyed.Run();
-}
-
 TEST_F(AndroidVideoSurfaceChooserImplTest, NullLaterOverlayUsesSurfaceTexture) {
   // If an overlay factory is provided after startup that returns a null overlay
   // from CreateOverlay, |chooser_| should, at most, notify |client_| to use
   // SurfaceTexture zero or more times.
 
   // Start with SurfaceTexture.
   EXPECT_CALL(client_, UseSurfaceTexture());
   StartChooser(AndroidOverlayFactoryCB());
   testing::Mock::VerifyAndClearExpectations(&client_);
 
@@ skipping 42 matching lines @@
   chooser_->ReplaceOverlayFactory(FactoryFor(std::move(overlay_)));
   testing::Mock::VerifyAndClearExpectations(&client_);
   testing::Mock::VerifyAndClearExpectations(this);
 
   // Notify |chooser_| that the overlay is ready.
   EXPECT_CALL(client_, UseOverlay(NotNull()));
   overlay_callbacks_.OverlayReady.Run();
 }
 
 }  // namespace media