Send enter / exit fullscreen signal to AVDA

media/gpu/android_video_decode_accelerator.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 <stddef.h>
 
 #include <memory>
 
@@ skipping 95 matching lines @@
 
 constexpr base::TimeDelta NoWaitTimeOut = base::TimeDelta::FromMicroseconds(0);
 
 constexpr base::TimeDelta IdleTimerTimeOut = base::TimeDelta::FromSeconds(1);
 
 // On low end devices (< KitKat is always low-end due to buggy MediaCodec),
 // defer the surface creation until the codec is actually used if we know no
 // software fallback exists.
 bool ShouldDeferSurfaceCreation(
     AVDACodecAllocator* codec_allocator,
-    int surface_id,
-    base::Optional<base::UnguessableToken> overlay_routing_token,
+    const OverlayInfo& overlay_info,
     VideoCodec codec,
     const AndroidVideoDecodeAccelerator::PlatformConfig& platform_config) {
   if (platform_config.force_deferred_surface_creation)
     return true;
 
   // TODO(liberato): We might still want to defer if we've got a routing
   // token.  It depends on whether we want to use it right away or not.
-  if (surface_id != SurfaceManager::kNoSurfaceID || overlay_routing_token)
+  if (overlay_info.HasValidSurfaceId() || overlay_info.HasValidRoutingToken())
     return false;
 
   return codec == kCodecH264 && codec_allocator->IsAnyRegisteredAVDA() &&
          platform_config.sdk_int <= base::android::SDK_VERSION_JELLY_BEAN_MR2;
 }
 
 std::unique_ptr<AndroidOverlay> CreateContentVideoViewOverlay(
     int32_t surface_id,
     AndroidOverlayConfig config) {
   return base::MakeUnique<ContentVideoViewOverlay>(surface_id,
@@ skipping 216 matching lines @@
   // SetSurface() can't be called before Initialize(), so we pick up our first
   // surface ID from the codec configuration.
   DCHECK(!pending_surface_id_);
 
   // We signaled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
 
   // If we're low on resources, we may decide to defer creation of the surface
   // until the codec is actually used.
-  if (ShouldDeferSurfaceCreation(codec_allocator_, config_.surface_id,
-                                 config_.overlay_routing_token,
+  if (ShouldDeferSurfaceCreation(codec_allocator_, config_.overlay_info,
                                  codec_config_->codec, platform_config_)) {
     // We should never be here if a SurfaceView is required.
     // TODO(liberato): This really isn't true with AndroidOverlay.
-    DCHECK_EQ(config_.surface_id, SurfaceManager::kNoSurfaceID);
+    DCHECK(!config_.overlay_info.HasValidSurfaceId());
     defer_surface_creation_ = true;
   }
 
   if (!codec_allocator_->StartThread(this)) {
     LOG(ERROR) << "Unable to start thread";
     return false;
   }
 
   // For encrypted media, start by initializing the CDM.  Otherwise, start with
   // the surface.
@@ skipping 31 matching lines @@
   //
   // Also note that we might choose to defer surface creation for the sync path,
   // which won't get here.  We'll exit above, successfully, during init, and
   // will fall through to the below when Decode calls us back.  That's okay.
   // We only handle this case specially since |surface_chooser_| is allowed to
   // post callbacks to us.  Here, we guarantee that the sync case is actually
   // resolved synchronously.  The only exception will be if we need to defer
   // surface creation for other reasons, in which case the sync path with just
   // signal success optimistically.
   if (during_initialize_ && !deferred_initialization_pending_) {
-    DCHECK_EQ(config_.surface_id, SurfaceManager::kNoSurfaceID);
-    DCHECK(!config_.overlay_routing_token);
+    DCHECK(!config_.overlay_info.HasValidSurfaceId());
+    DCHECK(!config_.overlay_info.HasValidRoutingToken());
     OnSurfaceTransition(nullptr);
     return;
   }
 
-  // If we have a surface, then notify |surface_chooser_| about it.
+  // If we have a surface, then notify |surface_chooser_| about it.  If we were
+  // told not to use an overlay (kNoSurfaceID or a null routing token), then we
+  // leave the factory blank.
   AndroidOverlayFactoryCB factory;
-  if (config_.surface_id != SurfaceManager::kNoSurfaceID)
-    factory = base::Bind(&CreateContentVideoViewOverlay, config_.surface_id);
-  else if (config_.overlay_routing_token && overlay_factory_cb_)
-    factory = base::Bind(overlay_factory_cb_, *config_.overlay_routing_token);
+  if (config_.overlay_info.HasValidSurfaceId()) {
+    factory = base::Bind(&CreateContentVideoViewOverlay,
+                         config_.overlay_info.surface_id);
+  } else if (config_.overlay_info.HasValidRoutingToken() &&
+             overlay_factory_cb_) {
+    factory =
+        base::Bind(overlay_factory_cb_, *config_.overlay_info.routing_token);
+  }
 
   // Notify |surface_chooser_| that we've started.  This guarantees that we'll
   // get a callback.  It might not be a synchronous callback, but we're not in
   // the synchronous case.  It will be soon, though.  For pre-M, we rely on the
   // fact that |surface_chooser_| won't tell us to use a SurfaceTexture while
   // waiting for an overlay to become ready, for example.
   surface_chooser_->Initialize(
       base::Bind(&AndroidVideoDecodeAccelerator::OnSurfaceTransition,
                  weak_this_factory_.GetWeakPtr()),
       base::Bind(&AndroidVideoDecodeAccelerator::OnSurfaceTransition,
@@ skipping 802 matching lines @@
                      weak_this_factory_.GetWeakPtr(), bitstream_buffer_id));
     }
   }
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount", 0);
   bitstreams_notified_in_advance_.clear();
 
   picture_buffer_manager_.ReleaseCodecBuffers(output_picture_buffers_);
   StartCodecDrain(DRAIN_FOR_RESET);
 }
 
-void AndroidVideoDecodeAccelerator::SetSurface(
-    int32_t surface_id,
-    const base::Optional<base::UnguessableToken>& routing_token) {
+void AndroidVideoDecodeAccelerator::SetOverlayInfo(
+    const OverlayInfo& overlay_info) {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // It's possible that we'll receive a SetSurface before initializing the
-  // surface chooser.  For example, if we defer surface creation, then we'll
-  // signal success to WMPI before initializing it.  WMPI is free to change the
-  // surface.  In this case, just pretend that |surface_id| is the initial one.
-  if (state_ == BEFORE_OVERLAY_INIT) {
-    config_.surface_id = surface_id;
-    config_.overlay_routing_token = routing_token;
+  // Update |config_| to contain the most recent info.  Also save a copy, so
+  // that we can check for duplicate info later.
+  OverlayInfo previous_info = config_.overlay_info;
+  config_.overlay_info = overlay_info;
+
+  // It's possible that we'll receive SetSurface before initializing the surface
+  // chooser.  For example, if we defer surface creation, then we'll signal
+  // success to WMPI before initializing it.  WMPI is then free to change
+  // |surface_id|.  In this case, take no additional action, since |config_| is
+  // up to date.  We'll use it later.
+  if (state_ == BEFORE_OVERLAY_INIT)
+    return;
+
+  // Note that these might be kNoSurfaceID / empty.  In that case, we will
+  // revoke the factory.
+  int32_t surface_id = overlay_info.surface_id;
+  OverlayInfo::RoutingToken routing_token = overlay_info.routing_token;
+
+  // We don't want to change the factory unless this info has actually changed.
+  // We'll get the same info many times if some other part of the config is now
+  // different, such as fullscreen state.
+  if (surface_id == previous_info.surface_id &&
+      routing_token == previous_info.routing_token) {
     return;
   }
 
   AndroidOverlayFactoryCB factory;
-  if (routing_token && overlay_factory_cb_) {
+  if (routing_token && overlay_factory_cb_)
     factory = base::Bind(overlay_factory_cb_, *routing_token);
-  } else if (surface_id != SurfaceManager::kNoSurfaceID) {
+  else if (surface_id != SurfaceManager::kNoSurfaceID)
     factory = base::Bind(&CreateContentVideoViewOverlay, surface_id);
-  }
 
   surface_chooser_->ReplaceOverlayFactory(std::move(factory));
 }
 
 void AndroidVideoDecodeAccelerator::Destroy() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   picture_buffer_manager_.Destroy(output_picture_buffers_);
   client_ = nullptr;
@@ skipping 408 matching lines @@
   codec_allocator_->ReleaseMediaCodec(std::move(media_codec_),
                                       codec_config_->surface_bundle);
 }
 
 void AndroidVideoDecodeAccelerator::ReleaseCodecAndBundle() {
   ReleaseCodec();
   codec_config_->surface_bundle = nullptr;
 }
 
 }  // namespace media