Add hints for potential overlay promotion on android.

cc/resources/resource_provider.cc

 // Copyright 2012 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 "cc/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 218 matching lines @@
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
       is_overlay_candidate(false),
+#if defined(OS_ANDROID)
+      is_backed_by_surface_texture(false),
+      wants_promotion_hint(false),
+#endif
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(target),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       hint(hint),
       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,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum filter)
     : child_id(0),
       gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       gl_read_lock_query_id(0),
       pixels(pixels),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(!!bitmap),
       is_overlay_candidate(false),
+#if defined(OS_ANDROID)
+      is_backed_by_surface_texture(false),
+      wants_promotion_hint(false),
+#endif
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       hint(TEXTURE_HINT_IMMUTABLE),
       type(RESOURCE_TYPE_BITMAP),
@@ skipping 18 matching lines @@
       imported_count(0),
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(true),
       is_overlay_candidate(false),
+#if defined(OS_ANDROID)
+      is_backed_by_surface_texture(false),
+      wants_promotion_hint(false),
+#endif
       read_lock_fence(nullptr),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       hint(TEXTURE_HINT_IMMUTABLE),
       type(RESOURCE_TYPE_BITMAP),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
-      shared_bitmap(nullptr) {}
+      shared_bitmap(nullptr) {
+}
 
 ResourceProvider::Resource::Resource(Resource&& other) = default;
 
 void ResourceProvider::Resource::set_mailbox(const TextureMailbox& mailbox) {
   mailbox_ = mailbox;
   if (IsGpuResourceType(type)) {
     synchronization_state_ =
         (mailbox.sync_token().HasData() ? NEEDS_WAIT : LOCALLY_USED);
     needs_sync_token_ = !mailbox.sync_token().HasData();
   } else {
@@ skipping 344 matching lines @@
                      Resource::EXTERNAL, GL_LINEAR));
   }
   resource->allocated = true;
   resource->set_mailbox(mailbox);
   resource->color_space = mailbox.color_space();
   resource->release_callback_impl =
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  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();
+  resource->wants_promotion_hint = mailbox.wants_promotion_hint();
+  if (resource->wants_promotion_hint)
+    wants_promotion_hints_set_.insert(id);
+#endif
   resource->color_space = mailbox.color_space();
 
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   return CreateResourceFromTextureMailbox(
       mailbox, std::move(release_callback_impl), false);
@@ skipping 16 matching lines @@
     DeleteResourceInternal(it, NORMAL);
   }
 }
 
 void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
                                               DeleteStyle style) {
   TRACE_EVENT0("cc", "ResourceProvider::DeleteResourceInternal");
   Resource* resource = &it->second;
   DCHECK(resource->exported_count == 0 || style != NORMAL);
 
+#if defined(OS_ANDROID)
+  // If this resource was interested in promotion hints, then remove it from
+  // the set of resources that we'll notify.
+  if (resource->wants_promotion_hint)
+    wants_promotion_hints_set_.erase(it->first);
+#endif
+
   // Exported resources are lost on shutdown.
   bool exported_resource_lost =
       style == FOR_SHUTDOWN && resource->exported_count > 0;
   // GPU resources are lost when context is lost.
   bool gpu_resource_lost =
       IsGpuResourceType(resource->type) && lost_context_provider_;
   bool lost_resource =
       resource->lost || exported_resource_lost || gpu_resource_lost;
 
   // Wait on sync token before deleting resources we own.
@@ skipping 308 matching lines @@
   return !resource->locked_for_write && !resource->lock_for_read_count &&
          !resource->exported_count && resource->origin == Resource::INTERNAL &&
          !resource->lost && ReadLockFenceHasPassed(resource);
 }
 
 bool ResourceProvider::IsOverlayCandidate(ResourceId id) {
   Resource* resource = GetResource(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;
+}
+
+bool ResourceProvider::WantsPromotionHint(ResourceId id) {
+  return wants_promotion_hints_set_.count(id) > 0;
+}
+
+size_t ResourceProvider::CountPromotionHintRequestsForTesting() {
+  return wants_promotion_hints_set_.size();
+}
+#endif
+
 void ResourceProvider::UnlockForWrite(Resource* resource) {
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->origin == Resource::INTERNAL);
   resource->locked_for_write = false;
 }
 
 void ResourceProvider::EnableReadLockFencesForTesting(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource);
@@ skipping 467 matching lines @@
       resource = InsertResource(
           local_id, Resource(0, it->size, Resource::DELEGATED,
                              it->mailbox_holder.texture_target, it->filter,
                              TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE,
                              it->format));
       resource->set_mailbox(TextureMailbox(it->mailbox_holder.mailbox,
                                            it->mailbox_holder.sync_token,
                                            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;
+      resource->wants_promotion_hint = it->wants_promotion_hint;
+      if (resource->wants_promotion_hint)
+        wants_promotion_hints_set_.insert(local_id);
+#endif
       resource->color_space = it->color_space;
     }
     resource->child_id = child;
     // Don't allocate a texture for a child.
     resource->allocated = true;
     resource->imported_count = 1;
     child_info.parent_to_child_map[local_id] = it->id;
     child_info.child_to_parent_map[it->id] = local_id;
   }
 }
@@ skipping 68 matching lines @@
     resources_for_child[resource->child_id].push_back(local_id);
   }
 
   for (const auto& children : resources_for_child) {
     ChildMap::iterator child_it = children_.find(children.first);
     DCHECK(child_it != children_.end());
     DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, children.second);
   }
 }
 
+#if defined(OS_ANDROID)
+void ResourceProvider::SendPromotionHints(
+    const ResourceIdSet& promotable_hints) {
+  for (const auto& it : wants_promotion_hints_set_) {

[piman, 2016/12/05 20:19:06]

nit: "id" or "resource_id" instead of "it"? This is not an iterator...

[liberato (no reviews please), 2016/12/05 21:50:47]

Done.

+    const Resource* resource = LockForRead(it);
+    DCHECK(resource->wants_promotion_hint);
+
+    // Insist that this is backed by a GPU texture.
+    if (IsGpuResourceType(resource->type)) {
+      DCHECK(resource->gl_id);
+      // Here we would either construct a set to send all at once, or send the
+      // promotion hint individually to resource->gl_id, based on whether
+      // promtable_hints.count(it->first) > 0 .

[piman, 2016/12/05 20:19:06]

nit: add a TODO(liberato), maybe link to a bug?

[liberato (no reviews please), 2016/12/05 21:50:47]

Done.

+    }
+    UnlockForRead(it);
+  }
+}
+#endif
+
 void ResourceProvider::CreateMailboxAndBindResource(
     gpu::gles2::GLES2Interface* gl,
     Resource* resource) {
   DCHECK(IsGpuResourceType(resource->type));
   DCHECK(gl);
 
   if (!resource->mailbox().IsValid()) {
     LazyCreate(resource);
 
     gpu::MailboxHolder mailbox_holder;
@@ skipping 19 matching lines @@
   DCHECK(!source->lock_for_read_count);
   DCHECK(source->origin != Resource::EXTERNAL || source->mailbox().IsValid());
   DCHECK(source->allocated);
   resource->id = id;
   resource->format = source->format;
   resource->mailbox_holder.texture_target = source->target;
   resource->filter = source->filter;
   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;
+  resource->wants_promotion_hint = source->wants_promotion_hint;
+#endif
   resource->color_space = source->color_space;
 
   if (source->type == RESOURCE_TYPE_BITMAP) {
     resource->mailbox_holder.mailbox = source->shared_bitmap_id;
     resource->is_software = true;
   } else {
     DCHECK(source->mailbox().IsValid());
     DCHECK(source->mailbox().IsTexture());
     DCHECK(!source->image_id || !source->dirty_image);
     // This is either an external resource, or a compositor resource that we
@@ skipping 386 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc