Assert sequence validity on non-thread-safe RefCount manipulations (2)

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 177 matching lines @@
   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) {
   base::AutoLock lock(g_lock.Get());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in TextureGroup.
+  base::ScopedAllowCrossThreadRefCountAccess
+      scoped_allow_cross_thread_ref_count_access;
   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,
                                         TextureBase* texture_base) {
   base::AutoLock lock(g_lock.Get());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in TextureGroup.
+  base::ScopedAllowCrossThreadRefCountAccess
+      scoped_allow_cross_thread_ref_count_access;
 
   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();
@@ skipping 27 matching lines @@
     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(TextureBase* texture_base) {
   base::AutoLock lock(g_lock.Get());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in TextureGroup.
+  base::ScopedAllowCrossThreadRefCountAccess
+      scoped_allow_cross_thread_ref_count_access;
 
   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);
@@ skipping 27 matching lines @@
     LOG(ERROR) << "MailboxSync: Incompatible attachment";
     return;
   }
 
   group->SetDefinition(TextureDefinition(texture, ++group_ref->version,
                                          image ? image_buffer : NULL));
 }
 
 void MailboxManagerSync::PushTextureUpdates(const SyncToken& token) {
   base::AutoLock lock(g_lock.Get());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects non-thread-safe RefCount in TextureGroup.
+  base::ScopedAllowCrossThreadRefCountAccess
+      scoped_allow_cross_thread_ref_count_access;
 
   for (TextureToGroupMap::iterator it = texture_to_group_.begin();
        it != texture_to_group_.end(); it++) {
     UpdateDefinitionLocked(it->first, &it->second);
   }
   CreateFenceLocked(token);
 }
 
 void MailboxManagerSync::PullTextureUpdates(const SyncToken& token) {
   using TextureUpdatePair = std::pair<Texture*, TextureDefinition>;
   std::vector<TextureUpdatePair> needs_update;
   {
     base::AutoLock lock(g_lock.Get());
+    // Relax the cross-thread access restriction to non-thread-safe RefCount.
+    // The lock above protects non-thread-safe RefCount in TextureGroup.
+    base::ScopedAllowCrossThreadRefCountAccess
+        scoped_allow_cross_thread_ref_count_access;
     AcquireFenceLocked(token);
 
     for (TextureToGroupMap::iterator it = texture_to_group_.begin();
          it != texture_to_group_.end(); it++) {
       const TextureDefinition& definition = it->second.group->GetDefinition();
       Texture* texture = it->first;
       unsigned& texture_version = it->second.version;
       if (texture_version == definition.version() ||
           definition.IsOlderThan(texture_version))
         continue;
       texture_version = definition.version();
       needs_update.push_back(TextureUpdatePair(texture, definition));
     }
   }
 
   if (!needs_update.empty()) {
     for (const TextureUpdatePair& pair : needs_update) {
       pair.second.UpdateTexture(pair.first);
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu