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 200 matching lines @@
 
     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 = static_cast<Texture*>(texture_base);
+  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 = static_cast<Texture*>(texture_base);
+  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 = static_cast<Texture*>(texture_base);
+  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