Fix Android black frames from MSE config changes.

content/common/gpu/media/android_copying_backing_strategy.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 "content/common/gpu/media/android_copying_backing_strategy.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
@@ skipping 117 matching lines @@
 
   // Here, we copy |surface_texture_id_| to the picture buffer instead of
   // setting new texture to |surface_texture_| by calling attachToGLContext()
   // because:
   // 1. Once we call detachFrameGLContext(), it deletes the texture previously
   //    attached.
   // 2. SurfaceTexture requires us to apply a transform matrix when we show
   //    the texture.
   // TODO(hkuang): get the StreamTexture transform matrix in GPU process
   // instead of using default matrix crbug.com/226218.
   copier_->DoCopyTextureWithTransform(

[liberato (no reviews please), 2016/03/02 16:50:36]

the problem might be here.  have you checked that this thing is using the right
sizes?  in CopyTextureCHROMIUMResourceManager::DoCopyTextureInternal, are you
getting the right src and dest sizes / x,y / offsets?  (you might want to log
only if target==external.  that thing is used a lot :) )

the changes you made elsewhere look fine.

[chcunningham, 2016/03/02 21:46:19]

Added this log just now. I sadly cant check it until I come back to office, but
after a quick code review I'm worried this may not be the source of our trouble.
We call this once we've gotten decoded frames back. The decoded frames should
have the size described by the most recent media codec format_change (which is
when we update AVDA's size_ member). IIUC this size is coming directly from AVDA
(as the state_provider_) so I expect to find everything in sync. I also expect
to find the x/y and offset values to all be 0, since they're just defaulted to
zero here:

https://code.google.com/p/chromium/codesearch#chromium/src/gpu/command_buffer...

We'll know for sure when I get a chance to run the test again. 

       state_provider_->GetGlDecoder().get(), GL_TEXTURE_EXTERNAL_OES,
       surface_texture_id_, GL_TEXTURE_2D, picture_buffer_texture_id,
       state_provider_->GetSize().width(), state_provider_->GetSize().height(),
       false, false, false, kIdentityMatrix);
 }
 
 void AndroidCopyingBackingStrategy::CodecChanged(
     media::VideoCodecBridge* codec,
     const AndroidVideoDecodeAccelerator::OutputBufferMap&) {
   media_codec_ = codec;
 }
 
 void AndroidCopyingBackingStrategy::OnFrameAvailable() {
   // TODO(liberato): crbug.com/574948 .  The OnFrameAvailable logic can be
   // moved into AVDA, and we should wait for it before doing the copy.
   // Because there were some test failures, we don't do this now but
   // instead preserve the old behavior.
 }
 
 bool AndroidCopyingBackingStrategy::ArePicturesOverlayable() {
   return false;
 }
 
+void AndroidCopyingBackingStrategy::UpdatePictureBufferSize(
+    media::PictureBuffer* picture_buffer,
+    const gfx::Size& new_size) {
+  LOG(ERROR) << __FUNCTION__ << " from:" << picture_buffer->size().ToString()
+             << " to:" << new_size.ToString();
+
+  // This strategy uses 2D textures who's allocated memory is dependent on the
+  // size. To update size in all places, we must:
+  // 1) Update the PictureBuffer meta-data
+  picture_buffer->set_size(new_size);
+
+  // 2) Update the GL texture via glTextImage2D. This step assumes the caller
+  // has made our GL context current.
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, new_size.width(), new_size.height(),
+               0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+  // 3) Update the CHROMIUM Texture's size.
+  gpu::gles2::TextureRef* texture_ref =
+      state_provider_->GetTextureForPicture(*picture_buffer);
+  RETURN_IF_NULL(texture_ref);
+  gpu::gles2::TextureManager* texture_manager =
+      state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
+  RETURN_IF_NULL(texture_manager);
+  texture_manager->SetLevelInfo(
+      texture_ref, GetTextureTarget(), 0, GL_RGBA, new_size.width(),
+      new_size.height(), 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+      gfx::Rect(new_size.width(),
+                new_size.height()));  // TODO CONSIDER USING EMPTY RECT
+}
+
 }  // namespace content