Use GL_SHARED_IMAGE_ACCESS_MODE_OVERLAY_CHROMIUM in GLRenderer

Introduce a viz::DisplayResourceProvider::ScopedOverlayLockGL structure,
which mirrors the ScopedReadLockGL, except it specifies a mode of
GL_SHARED_IMAGE_ACCESS_MODE_OVERLAY_CHROMIUM instead of the usual
GL_SHARED_IMAGE_ACCESS_MODE_READ_CHROMIUM.

This is ignored (and treated the same as READ) by all implementations,
but the next patch will use OVERLAY in a way that would break if READ
were specified.

Bug: 1092155
Change-Id: I4e23d6514b67b1f9960a08d206cde0765928ae2e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2255880Reviewed-by: ccameron <ccameron@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Commit-Queue: ccameron <ccameron@chromium.org>
Cr-Commit-Position: refs/heads/master@{#781427}

components/viz/service/display/display_resource_provider.cc

@@ -198,7 +198,7 @@ void DisplayResourceProvider::SendPromotionHints(
     if (it->second.marked_for_deletion)
       continue;
 
-    const ChildResource* resource = LockForRead(id);
+    const ChildResource* resource = LockForRead(id, false /* overlay_only */);
     // TODO(ericrk): We should never fail LockForRead, but we appear to be
     // doing so on Android in rare cases. Handle this gracefully until a better
     // solution can be found. https://crbug.com/811858
@@ -493,7 +493,7 @@ GLES2Interface* DisplayResourceProvider::ContextGL() const {
 }
 
 const DisplayResourceProvider::ChildResource*
-DisplayResourceProvider::LockForRead(ResourceId id) {
+DisplayResourceProvider::LockForRead(ResourceId id, bool overlay_only) {
   // TODO(ericrk): We should never fail TryGetResource, but we appear to be
   // doing so on Android in rare cases. Handle this gracefully until a better
   // solution can be found. https://crbug.com/811858
@@ -522,7 +522,9 @@ DisplayResourceProvider::LockForRead(ResourceId id) {
     if (mailbox.IsSharedImage() && enable_shared_images_ &&
         resource->lock_for_read_count == 0) {
       gl->BeginSharedImageAccessDirectCHROMIUM(
-          resource->gl_id, GL_SHARED_IMAGE_ACCESS_MODE_READ_CHROMIUM);
+          resource->gl_id, overlay_only
+                               ? GL_SHARED_IMAGE_ACCESS_MODE_OVERLAY_CHROMIUM
+                               : GL_SHARED_IMAGE_ACCESS_MODE_READ_CHROMIUM);
     }
   }
 
@@ -851,7 +853,8 @@ DisplayResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
     DisplayResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
-  const ChildResource* resource = resource_provider->LockForRead(resource_id);
+  const ChildResource* resource =
+      resource_provider->LockForRead(resource_id, false /* overlay_only */);
   // TODO(ericrk): We should never fail LockForRead, but we appear to be
   // doing so on Android in rare cases. Handle this gracefully until a better
   // solution can be found. https://crbug.com/811858
@@ -868,6 +871,22 @@ DisplayResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
+DisplayResourceProvider::ScopedOverlayLockGL::ScopedOverlayLockGL(
+    DisplayResourceProvider* resource_provider,
+    ResourceId resource_id)
+    : resource_provider_(resource_provider), resource_id_(resource_id) {
+  const ChildResource* resource =
+      resource_provider->LockForRead(resource_id, true);
+  if (!resource)
+    return;
+
+  texture_id_ = resource->gl_id;
+}
+
+DisplayResourceProvider::ScopedOverlayLockGL::~ScopedOverlayLockGL() {
+  resource_provider_->UnlockForRead(resource_id_);
+}
+
 DisplayResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
     DisplayResourceProvider* resource_provider,
     ResourceId resource_id,
@@ -893,7 +912,8 @@ DisplayResourceProvider::ScopedReadLockSkImage::ScopedReadLockSkImage(
     SkAlphaType alpha_type,
     GrSurfaceOrigin origin)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
-  const ChildResource* resource = resource_provider->LockForRead(resource_id);
+  const ChildResource* resource =
+      resource_provider->LockForRead(resource_id, false /* overlay_only */);
   DCHECK(resource);
 
   // Use cached SkImage if possible.

components/viz/service/display/display_resource_provider.h

@@ -158,6 +158,23 @@ class VIZ_SERVICE_EXPORT DisplayResourceProvider
     gfx::ColorSpace color_space_;
   };
 
+  class VIZ_SERVICE_EXPORT ScopedOverlayLockGL {
+   public:
+    ScopedOverlayLockGL(DisplayResourceProvider* resource_provider,
+                        ResourceId resource_id);
+    ~ScopedOverlayLockGL();
+
+    ScopedOverlayLockGL(const ScopedOverlayLockGL&) = delete;
+    ScopedOverlayLockGL& operator=(const ScopedOverlayLockGL&) = delete;
+
+    GLuint texture_id() const { return texture_id_; }
+
+   private:
+    DisplayResourceProvider* const resource_provider_;
+    const ResourceId resource_id_;
+    GLuint texture_id_ = 0;
+  };
+
   class VIZ_SERVICE_EXPORT ScopedSamplerGL {
    public:
     ScopedSamplerGL(DisplayResourceProvider* resource_provider,
@@ -521,7 +538,7 @@ class VIZ_SERVICE_EXPORT DisplayResourceProvider
   // Returns null if we do not have a ContextProvider.
   gpu::gles2::GLES2Interface* ContextGL() const;
 
-  const ChildResource* LockForRead(ResourceId id);
+  const ChildResource* LockForRead(ResourceId id, bool overlay_only);
   void UnlockForRead(ResourceId id);
 
   void TryReleaseResource(ResourceId id, ChildResource* resource);

components/viz/service/display/gl_renderer.cc

@@ -3528,7 +3528,7 @@ void GLRenderer::ScheduleCALayers() {
     unsigned texture_id = 0;
     if (contents_resource_id) {
       pending_overlay_resources_.push_back(
-          std::make_unique<DisplayResourceProvider::ScopedReadLockGL>(
+          std::make_unique<DisplayResourceProvider::ScopedOverlayLockGL>(
               resource_provider_, contents_resource_id));
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
@@ -3585,7 +3585,7 @@ void GLRenderer::ScheduleDCLayers() {
       if (resource_id == kInvalidResourceId)
         break;
       pending_overlay_resources_.push_back(
-          std::make_unique<DisplayResourceProvider::ScopedReadLockGL>(
+          std::make_unique<DisplayResourceProvider::ScopedOverlayLockGL>(
               resource_provider_, resource_id));
       texture_ids[i] = pending_overlay_resources_.back()->texture_id();
     }
@@ -3624,7 +3624,7 @@ void GLRenderer::ScheduleOverlays() {
   OverlayCandidateList& overlays = current_frame()->overlay_list;
   for (const auto& overlay_candidate : overlays) {
     pending_overlay_resources_.push_back(
-        std::make_unique<DisplayResourceProvider::ScopedReadLockGL>(
+        std::make_unique<DisplayResourceProvider::ScopedOverlayLockGL>(
             resource_provider_, overlay_candidate.resource_id));
     unsigned texture_id = pending_overlay_resources_.back()->texture_id();
 

components/viz/service/display/gl_renderer.h

@@ -155,7 +155,7 @@ class VIZ_SERVICE_EXPORT GLRenderer : public DirectRenderer {
   friend class GLRendererTest;
 
   using OverlayResourceLock =
-      std::unique_ptr<DisplayResourceProvider::ScopedReadLockGL>;
+      std::unique_ptr<DisplayResourceProvider::ScopedOverlayLockGL>;
   using OverlayResourceLockList = std::vector<OverlayResourceLock>;
 
   // If a RenderPass is used as an overlay, we render the RenderPass with any