Send enter / exit fullscreen signal to AVDA

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 319 matching lines @@
     vda_.reset(avda);
 
     bool result = vda_->Initialize(config_, &client_);
     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;
+    config_.overlay_info.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();
 
@@ skipping 129 matching lines @@
        LowEndDevicesSucceedInitWithoutASurface) {
   // If AVDA decides that we should defer surface creation, then it should
   // signal success before we provide a surface.  It should still ask for a
   // surface, though.
   SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
 
   // It would be nicer if we didn't just force this on, since we might do so
   // in a state that AVDA isn't supposed to handle (e.g., if we give it a
   // surface, then it would never decide to defer surface creation).
   platform_config_.force_deferred_surface_creation = true;
-  config_.surface_id = SurfaceManager::kNoSurfaceID;
+  config_.overlay_info.surface_id = SurfaceManager::kNoSurfaceID;
 
   EXPECT_CALL(*chooser_, MockInitialize()).Times(0);
   EXPECT_CALL(client_, NotifyInitializationComplete(true));
 
   InitializeAVDA();
 }
 
 TEST_F(AndroidVideoDecodeAcceleratorTest,
        AsyncInitWithSurfaceTextureAndDelete) {
   // When configuring with a SurfaceTexture and deferred init, we should be
@@ skipping 136 matching lines @@
   // If we ask AVDA to change to SurfaceTexture should be ignored on platforms
   // that don't support SetSurface (pre-M or blacklisted).  It should also
   // ignore SurfaceTexture => overlay, but we don't check that.
   //
   // Also note that there are other probably reasonable things to do (like
   // signal an error), but we want to be sure that it doesn't try to SetSurface.
   // We also want to be sure that, if it doesn't signal an error, that it also
   // doesn't get confused about which surface is in use.  So, we assume that it
   // doesn't signal an error, and we check that it releases the right surface
   // with the codec.
+  SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
   EXPECT_CALL(client_, NotifyError(_)).Times(0);
 
   platform_config_.allow_setsurface = false;
   InitializeAVDAWithOverlay();
   EXPECT_CALL(*codec_allocator_.most_recent_codec(), SetSurface(_)).Times(0);
 
   // This should not switch to SurfaceTexture.
   chooser_->ProvideSurfaceTexture();
   LetAVDAUpdateSurface();
 }
 
 TEST_F(AndroidVideoDecodeAcceleratorTest,
        OnSurfaceDestroyedWithoutSetSurfaceFreesTheCodec) {
   // If AVDA receives OnSurfaceDestroyed without support for SetSurface, then it
   // should free the codec.
+  SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
   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();
@@ skipping 13 matching lines @@
 
   InitializeAVDAWithSurfaceTexture();
 
   // This should do nothing.
   EXPECT_CALL(*codec_allocator_.most_recent_codec(), SetSurface(_)).Times(0);
   chooser_->ProvideSurfaceTexture();
 
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_F(AndroidVideoDecodeAcceleratorTest,
+       OverlayInfoWithDuplicateSurfaceIDDoesntChangeTheFactory) {
+  // Send OverlayInfo with duplicate info, and verify that it doesn't change
+  // the factory.
+  SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
+  InitializeAVDAWithOverlay();
+
+  EXPECT_CALL(*chooser_, MockReplaceOverlayFactory()).Times(0);
+  OverlayInfo overlay_info = config_.overlay_info;
+  avda()->SetOverlayInfo(overlay_info);
+}
+
+TEST_F(AndroidVideoDecodeAcceleratorTest,
+       OverlayInfoWithNewSurfaceIDDoesChangeTheFactory) {
+  // Send OverlayInfo with new surface info, and verify that it does change the
+  // overlay factory.
+  SKIP_IF_MEDIACODEC_IS_NOT_AVAILABLE();
+  InitializeAVDAWithOverlay();
+
+  EXPECT_CALL(*chooser_, MockReplaceOverlayFactory()).Times(1);
+  OverlayInfo overlay_info = config_.overlay_info;
+  overlay_info.surface_id++;
+  avda()->SetOverlayInfo(overlay_info);
+}
+
 }  // namespace media