Add a base class of Texture for interfacing with the mailbox manager.

gpu/command_buffer/service/mailbox_manager_sync.cc

 // Copyright 2014 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 "gpu/command_buffer/service/mailbox_manager_sync.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <queue>
@@ skipping 173 matching lines @@
   // EGL_KHR_gl_texture_2D_image and glEGLImageTargetTexture2DOES for
   // texture levels.
   bool has_mips = texture->NeedsMips() && texture->texture_complete();
   return texture->target() != GL_TEXTURE_2D || has_mips;
 }
 
 bool MailboxManagerSync::UsesSync() {
   return true;
 }
 
-Texture* MailboxManagerSync::ConsumeTexture(const Mailbox& mailbox) {
+TextureBase* MailboxManagerSync::ConsumeTexture(const Mailbox& mailbox) {

[piman, 2016/09/07 17:38:31]

nit: you can use covariant returns and return Texture here.

[Geoff Lang, 2016/09/07 18:14:49]

Done.

   base::AutoLock lock(g_lock.Get());
   TextureGroup* group = TextureGroup::FromName(mailbox);
   if (!group)
     return NULL;
 
   // Check if a texture already exists in this share group.
   Texture* texture = group->FindTexture(this);
   if (texture)
     return texture;
 
   // Otherwise create a new texture.
   texture = group->GetDefinition().CreateTexture();
   if (texture) {
     DCHECK(!SkipTextureWorkarounds(texture));
     texture->SetMailboxManager(this);
     group->AddTexture(this, texture);
 
     TextureGroupRef new_ref =
         TextureGroupRef(group->GetDefinition().version(), group);
     texture_to_group_.insert(std::make_pair(texture, new_ref));
   }
 
   return texture;
 }
 
 void MailboxManagerSync::ProduceTexture(const Mailbox& mailbox,
-                                        Texture* texture) {
+                                        TextureBase* texture_base) {
   base::AutoLock lock(g_lock.Get());
 
+  Texture* texture = texture_base->AsTexture();
+  DCHECK(texture != nullptr);
+
   TextureToGroupMap::iterator tex_it = texture_to_group_.find(texture);
   TextureGroup* group_for_mailbox = TextureGroup::FromName(mailbox);
   TextureGroup* group_for_texture = NULL;
 
   if (tex_it != texture_to_group_.end()) {
     group_for_texture = tex_it->second.group.get();
     DCHECK(group_for_texture);
     if (group_for_mailbox == group_for_texture) {
       // The texture is already known under this name.
       return;
@@ skipping 21 matching lines @@
     group_for_texture = new TextureGroup(definition);
     group_for_texture->AddTexture(this, texture);
     group_for_texture->AddName(mailbox);
     texture_to_group_.insert(std::make_pair(
         texture, TextureGroupRef(kNewTextureVersion, group_for_texture)));
   }
 
   DCHECK(texture->mailbox_manager_ == this);
 }
 
-void MailboxManagerSync::TextureDeleted(Texture* texture) {
+void MailboxManagerSync::TextureDeleted(TextureBase* texture_base) {
   base::AutoLock lock(g_lock.Get());
+
+  Texture* texture = texture_base->AsTexture();
+  DCHECK(texture != nullptr);
+
   TextureToGroupMap::iterator tex_it = texture_to_group_.find(texture);
   DCHECK(tex_it != texture_to_group_.end());
   TextureGroup* group_for_texture = tex_it->second.group.get();
   if (group_for_texture->RemoveTexture(this, texture))
     UpdateDefinitionLocked(texture, &tex_it->second);
   texture_to_group_.erase(tex_it);
 }
 
-void MailboxManagerSync::UpdateDefinitionLocked(
-    Texture* texture,
-    TextureGroupRef* group_ref) {
+void MailboxManagerSync::UpdateDefinitionLocked(TextureBase* texture_base,
+                                                TextureGroupRef* group_ref) {
   g_lock.Get().AssertAcquired();
 
+  Texture* texture = texture_base->AsTexture();
+  DCHECK(texture != nullptr);
+
   if (SkipTextureWorkarounds(texture))
     return;
 
   gl::GLImage* image = texture->GetLevelImage(texture->target(), 0);
   TextureGroup* group = group_ref->group.get();
   const TextureDefinition& definition = group->GetDefinition();
   scoped_refptr<NativeImageBuffer> image_buffer = definition.image();
 
   // Make sure we don't clobber with an older version
   if (!definition.IsOlderThan(group_ref->version))
@@ skipping 45 matching lines @@
 
   if (!needs_update.empty()) {
     for (const TextureUpdatePair& pair : needs_update) {
       pair.second.UpdateTexture(pair.first);
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu