Increase cases where back/front buffering early rendering occur.

media/gpu/android_deferred_rendering_backing_strategy.cc

Index: media/gpu/android_deferred_rendering_backing_strategy.cc
diff --git a/media/gpu/android_deferred_rendering_backing_strategy.cc b/media/gpu/android_deferred_rendering_backing_strategy.cc
index 1f6cfd74a8e019f5939af3f47975209e909dca77..cfe7d882da0f51b2a75b1a74e0aad27a631e30f5 100644
--- a/media/gpu/android_deferred_rendering_backing_strategy.cc
+++ b/media/gpu/android_deferred_rendering_backing_strategy.cc
@@ -147,7 +147,7 @@ void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
         shared_state_->surface_texture_service_id());
 
     static_cast<AVDACodecImage*>(image.get())
-        ->SetTexture(texture_ref->texture());
+        ->set_texture(texture_ref->texture());
   } else {
     // Clear the unowned service_id, so that this texture is no longer going
     // to depend on the surface texture at all.
@@ -183,8 +183,8 @@ void AndroidDeferredRenderingBackingStrategy::UseCodecBufferForPictureBuffer(
   // Note that this is not a race, since we do not re-use a PictureBuffer
   // until after the CC is done drawing it.
   pictures_out_for_display_.push_back(picture_buffer.id());
-  avda_image->SetMediaCodecBufferIndex(codec_buf_index);
-  avda_image->SetSize(state_provider_->GetSize());
+  avda_image->set_media_codec_buffer_index(codec_buf_index);
+  avda_image->set_size(state_provider_->GetSize());
 
   MaybeRenderEarly();
 }
@@ -246,46 +246,58 @@ void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBuffers(
 }
 
 void AndroidDeferredRenderingBackingStrategy::MaybeRenderEarly() {
-  // See if we can consume the front buffer / render to the SurfaceView.
-  if (pictures_out_for_display_.size() == 1u) {
-    AVDACodecImage* avda_image =
-        shared_state_->GetImageForPicture(*pictures_out_for_display_.begin());
-    RETURN_IF_NULL(avda_image);
-    avda_image->UpdateSurface(
-        AVDACodecImage::UpdateMode::RENDER_TO_FRONT_BUFFER);
-    return;
-  }
-
-  // Back buffer rendering is only available for surface textures.
-  if (!surface_texture_)
+  if (pictures_out_for_display_.empty())
     return;
 
-  // See if the back buffer is free. If so, then render the earliest frame.  The
-  // listing is in render order, so we can just use the first unrendered frame
-  // if there is back buffer space.
+  // See if we can consume the front buffer / render to the SurfaceView. Iterate
+  // in reverse to find the most recent front buffer. If none is found, the
+  // |front_index| will point to the beginning of the array.
+  size_t front_index = pictures_out_for_display_.size() - 1;
   AVDACodecImage* first_renderable_image = nullptr;
-  for (int id : pictures_out_for_display_) {
+  for (int i = front_index; i >= 0; --i) {
+    const int id = pictures_out_for_display_[i];
     AVDACodecImage* avda_image = shared_state_->GetImageForPicture(id);
     if (!avda_image)
       continue;
 
-    // If the back buffer is unavailable, there's nothing left to do.
-    if (avda_image->is_rendered_to_back_buffer())
-      return;
-
-    // If the image is rendered to the front buffer or has been dropped, it is
-    // not valid for rendering.
-    if (avda_image->is_rendered())
-      continue;
+    // If we find a front buffer, stop and indicate that front buffer rendering
+    // is not possible since another image is already in the front buffer.
+    if (avda_image->was_rendered_to_front_buffer()) {
+      first_renderable_image = nullptr;
+      break;
+    }
 
-    if (!first_renderable_image)
-      first_renderable_image = avda_image;
+    // Update the front buffer index as we move along to shorten the number of
+    // candidate images we look at for back buffer rendering.
+    front_index = i;
+    first_renderable_image = avda_image;
   }
 
   if (first_renderable_image) {
     first_renderable_image->UpdateSurface(
-        AVDACodecImage::UpdateMode::RENDER_TO_BACK_BUFFER);
+        AVDACodecImage::UpdateMode::RENDER_TO_FRONT_BUFFER);
   }
+
+  // Back buffer rendering is only available for surface textures. We'll always
+  // have at least one front buffer, so the next buffer must be the backbuffer.
+  size_t backbuffer_index = front_index + 1;
+  if (!surface_texture_ || backbuffer_index >= pictures_out_for_display_.size())
+    return;
+
+  // See if the back buffer is free. If so, then render the frame adjacent to
+  // the front buffer.  The listing is in render order, so we can just use the
+  // first unrendered frame if there is back buffer space.
+  first_renderable_image = shared_state_->GetImageForPicture(
+      pictures_out_for_display_[backbuffer_index]);
+  if (!first_renderable_image ||
+      first_renderable_image->was_rendered_to_back_buffer()) {
+    return;
+  }
+
+  // Due to the loop in the beginning this should never be true.
+  DCHECK(!first_renderable_image->was_rendered_to_front_buffer());
+  first_renderable_image->UpdateSurface(

[liberato (no reviews please), 2016/05/03 15:20:55]

this will force a wait for frame available after your other CL.  unsure if
that's a win or not, especially when we're on a device that often hits the
OnFrameAvailable timeout.  the alternative of waiting during drawing seems
worse, but we might not draw this frame at all and we're holding up frame
delivery and (potentially) the next draw here anyway.

the alternative is to do this only when the signal has arrived or the timeout
has elapsed.  in that case, consider having OnFrameAvailable post a task back to
the main thread to MaybeRenderEarly.

[DaleCurtis, 2016/05/03 21:13:34]

I don't follow. The render to front buffer above always waits since we release
to the front buffer, this on the other hand should release but not wait.

[liberato (no reviews please), 2016/05/03 21:31:49]

hrm, my comment was pretty jumbly.  sorry about that.

my concern is that we'll now incur a WaitForFrameAvailable for frames that we
don't ever draw, and we're still waiting on the critical path.

right now, this tries "render to front buffer" then "render to back buffer". 
however, it might do better to "render to back buffer" and "promote back buffer
to front buffer".  then it's easy to defer the promotion until after the frame
available has happened.

after your other CL (https://codereview.chromium.org/1924973004/), we'll have
that ability pretty easily.

might need to wait for your other CL to land, though.

[DaleCurtis, 2016/05/04 00:01:33]

So you're advocating that in the case where we have neither a front buffer nor a
back buffer, that we only render the back buffer and let the promotion happen
the next time this method is called or during the draw phase.

This seemed reasonable, so I tried it, but it has the opposite of the intended
effect, everything slows down since the MediaCodec is hitting the stalled state
for lack of buffers again.

[liberato (no reviews please), 2016/05/04 00:10:01]

hrm, that's unexpected, since we're still releasing the buffer from media
codec's point of view.  it must be resulting in fewer releases, meaning that
we're spending more time waiting to get the cpu back on the gpu main thread (or
that 10msec DoIOTask poll is too slow) than the frame available timer takes.

oh, well.  thanks for trying it out.

+      AVDACodecImage::UpdateMode::RENDER_TO_BACK_BUFFER);
 }
 
 void AndroidDeferredRenderingBackingStrategy::CodecChanged(