Add multiple destruction callbacks to AndroidOverlay.

media/gpu/android_video_surface_chooser_impl.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"
 
 namespace media {
 
 AndroidVideoSurfaceChooserImpl::AndroidVideoSurfaceChooserImpl()
     : weak_factory_(this) {}
 
 AndroidVideoSurfaceChooserImpl::~AndroidVideoSurfaceChooserImpl() {}
 
 void AndroidVideoSurfaceChooserImpl::Initialize(
     UseOverlayCB use_overlay_cb,
     UseSurfaceTextureCB use_surface_texture_cb,
-    StopUsingOverlayImmediatelyCB stop_immediately_cb,
     AndroidOverlayFactoryCB 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);
 
   if (initial_factory) {
     // We requested an overlay.  Wait to see if it succeeds or fails, since
     // hopefully this will be fast.  On M+, we could ask it to start with a
     // SurfaceTexture either way.  Before M, we can't switch surfaces.  In that
     // case, it's important not to request a SurfaceTexture if we have an
     // overlay pending, so that we know not to transition to SurfaceTexture.
     client_notification_pending_ = true;
     ReplaceOverlayFactory(std::move(initial_factory));
   }
@@ skipping 39 matching lines @@
   // between the two.
   AndroidOverlayConfig config;
   // We bind all of our callbacks with weak ptrs, since we don't know how long
   // the client will hold on to overlays.  They could, in principle, show up
   // long after the client is destroyed too, if codec destruction hangs.
   config.ready_cb = base::Bind(&AndroidVideoSurfaceChooserImpl::OnOverlayReady,
                                weak_factory_.GetWeakPtr());
   config.failed_cb =
       base::Bind(&AndroidVideoSurfaceChooserImpl::OnOverlayFailed,
                  weak_factory_.GetWeakPtr());
-  config.destroyed_cb =
-      base::Bind(&AndroidVideoSurfaceChooserImpl::OnSurfaceDestroyed,
-                 weak_factory_.GetWeakPtr());
   // TODO(liberato): where do we get the initial size from?  For CVV, it's
   // set via the natural size, and this is ignored anyway.  The client should
   // provide this.
   config.rect = gfx::Rect(0, 0, 1, 1);
   overlay_ = overlay_factory_.Run(std::move(config));
+  // We could add a destruction callback here, if we need to find out when the
+  // surface has been destroyed.  It might also be good to have a 'overlay has
+  // been destroyed' callback from ~AndroidOverlay, since we don't really know
+  // how long that will take after SurfaceDestroyed.
 }
 
 void AndroidVideoSurfaceChooserImpl::OnOverlayReady(AndroidOverlay* overlay) {
   // |overlay_| is the only overlay for which we haven't gotten a ready callback
   // back yet.
   DCHECK_EQ(overlay, overlay_.get());
 
   // If we haven't sent the client notification yet, we're doing so now.
   client_notification_pending_ = false;
 
   use_overlay_cb_.Run(std::move(overlay_));
 }
 
 void AndroidVideoSurfaceChooserImpl::OnOverlayFailed(AndroidOverlay* overlay) {
   // We shouldn't get a failure for any overlay except the incoming one.
   DCHECK_EQ(overlay, overlay_.get());
 
   // If we owe the client a notification callback, then send it.
   if (client_notification_pending_) {
     // The overlay that we requested failed, so notify the client to try
     // using SurfaceTexture instead.
     client_notification_pending_ = false;
     use_surface_texture_cb_.Run();
   }
 
   overlay_ = nullptr;
 }
 
-void AndroidVideoSurfaceChooserImpl::OnSurfaceDestroyed(
-    AndroidOverlay* overlay) {
-  // We shouldn't get OnSurfaceDestroyed unless we previously got Ready.  In
-  // that case, we should have notified the client then.
-  DCHECK(!client_notification_pending_);
-
-  // We should not get OnSurfaceDestroyed for the incoming overlay, since we
-  // should't get OnSurfaceDestroyed before OnSurfaceReady.  OnSurfaceReady
-  // should imply that this isn't the incoming overlay.
-  DCHECK_NE(overlay_.get(), overlay);
-
-  // We unconditionally send 'stop immediately', since we don't know what
-  // overlay this is.  Even if we revoked the overlay before, we may have done
-  // so with the slow transition, which isn't good enough now.  The client has
-  // to be smart enoug to understand if it's currently using |overlay| or not.
-
-  // Also remember that we don't know when the client drops the overlay, after
-  // we revoke it.  We can get callbacks until that happens, even if (for
-  // example), the overlay is waiting for MediaCodec destruction.  So, it's
-  // likely that we'll send callbacks for overlays that the client is already
-  // not using.
-  stop_immediately_cb_.Run(overlay);
-}
-
 }  // namespace media