Add hints for potential overlay promotion on android.

cc/resources/resource_provider.cc

Index: cc/resources/resource_provider.cc
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 18cabee1cab1040434ad98fbe9ebc9d3a0e259cf..45a487847b384318fb52c0594f8363665a430f83 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -236,6 +236,9 @@ ResourceProvider::Resource::Resource(GLuint texture_id,
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
       is_overlay_candidate(false),
+#if defined(OS_ANDROID)
+      is_backed_by_surface_texture(false),
+#endif
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
@@ -248,7 +251,8 @@ ResourceProvider::Resource::Resource(GLuint texture_id,
       type(type),
       usage(gfx::BufferUsage::GPU_READ_CPU_READ_WRITE),
       format(format),
-      shared_bitmap(nullptr) {}
+      shared_bitmap(nullptr) {
+}
 
 ResourceProvider::Resource::Resource(uint8_t* pixels,
                                      SharedBitmap* bitmap,
@@ -272,6 +276,9 @@ ResourceProvider::Resource::Resource(uint8_t* pixels,
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(!!bitmap),
       is_overlay_candidate(false),
+#if defined(OS_ANDROID)
+      is_backed_by_surface_texture(false),
+#endif
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
@@ -310,6 +317,9 @@ ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(true),
       is_overlay_candidate(false),
+#if defined(OS_ANDROID)
+      is_backed_by_surface_texture(false),
+#endif
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
@@ -322,7 +332,8 @@ ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
       type(RESOURCE_TYPE_BITMAP),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
-      shared_bitmap(nullptr) {}
+      shared_bitmap(nullptr) {
+}
 
 ResourceProvider::Resource::Resource(Resource&& other) = default;
 
@@ -687,6 +698,10 @@ ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
                  base::Owned(release_callback_impl.release()));
   resource->read_lock_fences_enabled = read_lock_fences_enabled;
   resource->is_overlay_candidate = mailbox.is_overlay_candidate();
+#if defined(OS_ANDROID)
+  resource->is_backed_by_surface_texture =
+      mailbox.is_backed_by_surface_texture();
+#endif
   resource->color_space = mailbox.color_space();
 
   return id;
@@ -1048,6 +1063,13 @@ bool ResourceProvider::IsOverlayCandidate(ResourceId id) {
   return resource->is_overlay_candidate;
 }
 
+#if defined(OS_ANDROID)
+bool ResourceProvider::IsBackedBySurfaceTexture(ResourceId id) {
+  Resource* resource = GetResource(id);
+  return resource->is_backed_by_surface_texture;
+}
+#endif
+
 void ResourceProvider::UnlockForWrite(Resource* resource) {
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
@@ -1532,6 +1554,9 @@ void ResourceProvider::ReceiveFromChild(
                                            it->mailbox_holder.texture_target));
       resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
       resource->is_overlay_candidate = it->is_overlay_candidate;
+#if defined(OS_ANDROID)
+      resource->is_backed_by_surface_texture = it->is_backed_by_surface_texture;

[piman, 2016/11/23 00:37:25]

note, however we will use this, we can't trust that the renderer gave us the
correct value. If it didn't, we don't have to display properly, but we can't
crash. I think at the end of the day it means that we need to handle the fact
that we may end up calling ScheduleOverlayPlane with a SurfaceTexture, or try to
draw with a SurfaceView, and we just need to maybe ignore the
ScheduleOverlayPlane in the first case and draw with a default texture in the
second case.

[liberato (no reviews please), 2016/12/01 20:59:11]

currently, the renderer can always mark the mailbox as an overlay candidate,
whether it is backed by ST or SV or anything else.  i think that it's handled
properly now, and that the behavior is unchanged here.

for AVDA in particular, there's still a texture + AVDACodecImage that
understands whether an overlay is okay or not.  attempting to draw a SV will use
an external texture with no glimage attached.  promoting a ST will return false
from ScheduleOverlayPlane.

+#endif
       resource->color_space = it->color_space;
     }
     resource->child_id = child;
@@ -1659,6 +1684,9 @@ void ResourceProvider::TransferResource(Resource* source,
   resource->size = source->size;
   resource->read_lock_fences_enabled = source->read_lock_fences_enabled;
   resource->is_overlay_candidate = source->is_overlay_candidate;
+#if defined(OS_ANDROID)
+  resource->is_backed_by_surface_texture = source->is_backed_by_surface_texture;
+#endif
   resource->color_space = source->color_space;
 
   if (source->type == RESOURCE_TYPE_BITMAP) {