removed AndroidOverlayFactory

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 19 matching lines @@
 #include "media/base/android/media_codec_util.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/gpu/android_video_surface_chooser_impl.h"
 #include "media/gpu/avda_picture_buffer_manager.h"
 #include "media/gpu/content_video_view_overlay.h"
-#include "media/gpu/content_video_view_overlay_factory.h"
 #include "media/gpu/shared_memory_region.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 #include "media/mojo/services/mojo_cdm_service.h"  // nogncheck
 #endif
 
@@ skipping 64 matching lines @@
     AVDACodecAllocator* codec_allocator,
     int surface_id,
     VideoCodec codec,
     const AndroidVideoDecodeAccelerator::PlatformConfig& platform_config) {
   return platform_config.force_deferred_surface_creation ||
          (surface_id == SurfaceManager::kNoSurfaceID && codec == kCodecH264 &&
           codec_allocator->IsAnyRegisteredAVDA() &&
           platform_config.sdk_int <= 18);
 }
 
+std::unique_ptr<AndroidOverlay> CreateContentVideoViewOverlay(
+    int32_t surface_id,
+    AndroidOverlayConfig config) {
+  return base::MakeUnique<ContentVideoViewOverlay>(surface_id,
+                                                   std::move(config));
+}
+
 }  // namespace
 
 // AVDAManager manages a RepeatingTimer so that AVDAs can get a regular callback
 // to DoIOTask().
 class AVDAManager {
  public:
   AVDAManager() {}
 
   // Request periodic callback of |avda|->DoIOTask(). Does nothing if the
   // instance is already registered and the timer started. The first request
@@ skipping 260 matching lines @@
   // 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);
     OnSurfaceTransition(nullptr);
     return;
   }
 
   // If we have a surface, then notify |surface_chooser_| about it.
-  std::unique_ptr<AndroidOverlayFactory> factory;
-  if (config_.surface_id != SurfaceManager::kNoSurfaceID) {
-    factory =
-        base::MakeUnique<ContentVideoViewOverlayFactory>(config_.surface_id);
-  }
+  AndroidOverlayFactoryCB factory;
+  if (config_.surface_id != SurfaceManager::kNoSurfaceID)
+    factory = base::Bind(&CreateContentVideoViewOverlay, config_.surface_id);
 
   // 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 847 matching lines @@
 
   // 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;
     return;
   }
 
-  std::unique_ptr<AndroidOverlayFactory> factory;
+  AndroidOverlayFactoryCB factory;
   if (surface_id != SurfaceManager::kNoSurfaceID)
-    factory = base::MakeUnique<ContentVideoViewOverlayFactory>(surface_id);
+    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 404 matching lines @@
                                       codec_config_->task_type,
                                       codec_config_->surface_bundle);
 }
 
 void AndroidVideoDecodeAccelerator::ReleaseCodecAndBundle() {
   ReleaseCodec();
   codec_config_->surface_bundle = nullptr;
 }
 
 }  // namespace media