Use MediaCodec.setOutputSurface() for fullscreen transitions on M.

media/gpu/avda_codec_image.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_codec_image.h"
 
 #include <string.h>
 
 #include <memory>
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/gpu/avda_shared_state.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace media {
 
 AVDACodecImage::AVDACodecImage(
     const scoped_refptr<AVDASharedState>& shared_state,
     VideoCodecBridge* codec,
     const base::WeakPtr<gpu::gles2::GLES2Decoder>& decoder)
     : shared_state_(shared_state),
       codec_buffer_index_(kInvalidCodecBufferIndex),
       media_codec_(codec),
       decoder_(decoder),
-      has_surface_texture_(!!shared_state_->surface_texture_service_id()),
+      has_surface_texture_(false),
       texture_(0) {}
 
 AVDACodecImage::~AVDACodecImage() {}
 
 gfx::Size AVDACodecImage::GetSize() {
   return size_;
 }
 
 unsigned AVDACodecImage::GetInternalFormat() {
   return GL_RGBA;
@@ skipping 85 matching lines @@
 
 void AVDACodecImage::UpdateSurface(UpdateMode update_mode) {
   UpdateSurfaceInternal(update_mode, kDoRestoreBindings);
 }
 
 void AVDACodecImage::CodecChanged(MediaCodecBridge* codec) {
   media_codec_ = codec;
   codec_buffer_index_ = kInvalidCodecBufferIndex;
 }
 
+void AVDACodecImage::SetBufferMetadata(int buffer_index,
+                                       bool has_surface_texture,
+                                       const gfx::Size& size) {
+  has_surface_texture_ = has_surface_texture;
+  codec_buffer_index_ = buffer_index;
+  size_ = size;
+}
+
+bool AVDACodecImage::SetSharedState(
+    const scoped_refptr<AVDASharedState>& shared_state) {

[dcheng, 2016/11/09 18:16:29]

Nit: it's preferred to pass by value and std::move() where appropriate to avoid
refcount thrashing.

[DaleCurtis, 2016/11/09 21:58:17]

Done.

+  if (shared_state == shared_state_)
+    return false;
+  shared_state_ = shared_state;
+  return true;
+}
+
 void AVDACodecImage::UpdateSurfaceInternal(
     UpdateMode update_mode,
     RestoreBindingsMode attached_bindings_mode) {
   if (!IsCodecBufferOutstanding())
     return;
 
   ReleaseOutputBuffer(update_mode);
 
   // SurfaceViews are updated implicitly, so no further steps are necessary.
   if (!has_surface_texture_) {
@@ skipping 68 matching lines @@
 }
 
 bool AVDACodecImage::IsCodecBufferOutstanding() const {
   static_assert(kUpdateOnly < 0 && kUpdateOnly > kRendered &&
                     kRendered > kInvalidCodecBufferIndex,
                 "Codec buffer index enum values are not ordered correctly.");
   return codec_buffer_index_ > kRendered && media_codec_;
 }
 
 }  // namespace media