cc: Rework overlays to not use the ResourceProvider and pass texture size

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 <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 255 matching lines @@
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
-      allow_overlay(false),
       read_lock_fence(NULL),
       size(size),
       origin(origin),
       target(target),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(texture_pool),
       wrap_mode(wrap_mode),
@@ skipping 23 matching lines @@
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(!!bitmap),
-      allow_overlay(false),
       read_lock_fence(NULL),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
@@ skipping 24 matching lines @@
       exported_count(0),
       dirty_image(false),
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(true),
-      allow_overlay(false),
       read_lock_fence(NULL),
       size(size),
       origin(origin),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
@@ skipping 73 matching lines @@
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0 ||
          resource->lost;
 }
 
 bool ResourceProvider::IsLost(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lost;
 }
 
-bool ResourceProvider::AllowOverlay(ResourceId id) {
-  Resource* resource = GetResource(id);
-  return resource->allow_overlay;
-}
-
 ResourceId ResourceProvider::CreateResource(const gfx::Size& size,
                                             GLint wrap_mode,
                                             TextureHint hint,
                                             ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GL_TEXTURE:
       return CreateGLTexture(size,
                              GL_TEXTURE_2D,
                              GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
@@ skipping 90 matching lines @@
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource* resource = nullptr;
   if (mailbox.IsTexture()) {
     resource = InsertResource(
-        id, Resource(0, gfx::Size(), Resource::EXTERNAL, mailbox.target(),
+        id, Resource(0, mailbox.size(), Resource::EXTERNAL, mailbox.target(),

[danakj, 2015/05/29 20:04:15]

if we're not going to use the size maybe just leave this empty here?

[achaulk, 2015/06/01 15:43:10]

Done.

                      mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR, 0,
                      GL_CLAMP_TO_EDGE, TEXTURE_HINT_IMMUTABLE, RGBA_8888));
   } else {
     DCHECK(mailbox.IsSharedMemory());
     SharedBitmap* shared_bitmap = mailbox.shared_bitmap();
     uint8_t* pixels = shared_bitmap->pixels();
     DCHECK(pixels);
     resource = InsertResource(
-        id, Resource(pixels, shared_bitmap, mailbox.shared_memory_size(),
-                     Resource::EXTERNAL, GL_LINEAR, GL_CLAMP_TO_EDGE));
+        id, Resource(pixels, shared_bitmap, mailbox.size(), Resource::EXTERNAL,
+                     GL_LINEAR, GL_CLAMP_TO_EDGE));
   }
   resource->allocated = true;
   resource->mailbox = mailbox;
   resource->release_callback_impl =
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  base::Owned(release_callback_impl.release()));
-  resource->allow_overlay = mailbox.allow_overlay();
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->marked_for_deletion);
   DCHECK_EQ(resource->imported_count, 0);
@@ skipping 779 matching lines @@
                              it->is_repeated ? GL_REPEAT : GL_CLAMP_TO_EDGE,
                              TEXTURE_HINT_IMMUTABLE, it->format));
       resource->mailbox = TextureMailbox(it->mailbox_holder.mailbox,
                                          it->mailbox_holder.texture_target,
                                          it->mailbox_holder.sync_point);
     }
     resource->child_id = child;
     // Don't allocate a texture for a child.
     resource->allocated = true;
     resource->imported_count = 1;
-    resource->allow_overlay = it->allow_overlay;
     child_info.parent_to_child_map[local_id] = it->id;
     child_info.child_to_parent_map[it->id] = local_id;
   }
 }
 
 void ResourceProvider::DeclareUsedResourcesFromChild(
     int child,
     const ResourceIdSet& resources_from_child) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 83 matching lines @@
   DCHECK(!source->locked_for_write);
   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->is_repeated = (source->wrap_mode == GL_REPEAT);
-  resource->allow_overlay = source->allow_overlay;
 
   if (source->type == RESOURCE_TYPE_BITMAP) {
     resource->mailbox_holder.mailbox = source->shared_bitmap_id;
     resource->is_software = true;
   } else if (!source->mailbox.IsValid()) {
     LazyCreate(source);
     DCHECK(source->gl_id);
     DCHECK(source->origin == Resource::INTERNAL);
     if (source->image_id) {
       DCHECK(source->dirty_image);
@@ skipping 551 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc