Add ContentVideoViewOverlay to AVDA.

media/gpu/avda_picture_buffer_manager.cc

 // Copyright 2015 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/avda_picture_buffer_manager.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_stream_texture_image.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/texture_manager.h"
-#include "gpu/ipc/common/gpu_surface_lookup.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_bridge_impl.h"
 #include "media/gpu/avda_codec_image.h"
 #include "media/gpu/avda_shared_state.h"
+#include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 
 // If !|ptr|, log a message, notify |state_provider_| of the error, and
 // return an optional value.
 #define RETURN_IF_NULL(ptr, ...)                                           \
   do {                                                                     \
     if (!(ptr)) {                                                          \
       DLOG(ERROR) << "Got null for " << #ptr;                              \
       state_provider_->NotifyError(VideoDecodeAccelerator::ILLEGAL_STATE); \
       return __VA_ARGS__;                                                  \
     }                                                                      \
   } while (0)
 
 namespace media {
 namespace {
 
 // Creates a SurfaceTexture and attaches a new gl texture to it.
 scoped_refptr<SurfaceTextureGLOwner> CreateAttachedSurfaceTexture(
     base::WeakPtr<gpu::gles2::GLES2Decoder> gl_decoder) {
   scoped_refptr<SurfaceTextureGLOwner> surface_texture =
       SurfaceTextureGLOwner::Create();
-  DCHECK(surface_texture);
+  if (!surface_texture)
+    return nullptr;
 
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_EXTERNAL_OES, surface_texture->texture_id());
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
   gl_decoder->RestoreTextureUnitBindings(0);
   gl_decoder->RestoreActiveTexture();
   DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 
   return surface_texture;
 }
 
 }  // namespace
 
 AVDAPictureBufferManager::AVDAPictureBufferManager(
     AVDAStateProvider* state_provider)
     : state_provider_(state_provider), media_codec_(nullptr) {}
 
 AVDAPictureBufferManager::~AVDAPictureBufferManager() {}
 
-gl::ScopedJavaSurface AVDAPictureBufferManager::Initialize(int surface_id) {
+void AVDAPictureBufferManager::InitializeForOverlay() {
+  shared_state_ = new AVDASharedState();
+  surface_texture_ = nullptr;
+}
+
+gl::ScopedJavaSurface AVDAPictureBufferManager::InitializeForSurfaceTexture() {
   shared_state_ = new AVDASharedState();
   surface_texture_ = nullptr;
 
-  // Acquire the SurfaceView surface if given a valid id.
-  if (surface_id != SurfaceManager::kNoSurfaceID)
-    return gpu::GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(surface_id);
-
-  // Otherwise create a SurfaceTexture.
+  // Create a SurfaceTexture.
   surface_texture_ =
       CreateAttachedSurfaceTexture(state_provider_->GetGlDecoder());
+  if (!surface_texture_)
+    return gl::ScopedJavaSurface();
+
   shared_state_->SetSurfaceTexture(surface_texture_);
   return gl::ScopedJavaSurface(surface_texture_.get());
 }
 
 void AVDAPictureBufferManager::Destroy(const PictureBufferMap& buffers) {
   // Do nothing if Initialize() has not been called.
   if (!shared_state_)
     return;
 
   ReleaseCodecBuffers(buffers);
@@ skipping 180 matching lines @@
 
 bool AVDAPictureBufferManager::HasUnrenderedPictures() const {
   for (int id : pictures_out_for_display_) {
     if (GetImageForPicture(id)->is_unrendered())
       return true;
   }
   return false;
 }
 
 }  // namespace media