cc: Do not verify resource sync tokens unnecessarily.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1349 matching lines @@
     DCHECK(!delegated_sync_points_required_ ||
            Resource::LOCALLY_USED != resource->synchronization_state());
 
     resources.push_back(resource);
   }
 
   // Lazily create any mailboxes and verify all unverified sync tokens.
   std::vector<GLbyte*> unverified_sync_tokens;
   std::vector<Resource*> need_synchronization_resources;
   for (Resource* resource : resources) {
+    if (!IsGpuResourceType(resource->type))
+      continue;
+
     CreateMailboxAndBindResource(gl, resource);
 
-    if (delegated_sync_points_required_ && resource->needs_sync_token()) {
-      need_synchronization_resources.push_back(resource);
-    } else if (resource->mailbox().HasSyncToken() &&
-               !resource->mailbox().sync_token().verified_flush()) {
-      unverified_sync_tokens.push_back(resource->GetSyncTokenData());
+    if (delegated_sync_points_required_) {
+      if (resource->needs_sync_token()) {
+        need_synchronization_resources.push_back(resource);
+      } else if (resource->mailbox().HasSyncToken() &&
+                 !resource->mailbox().sync_token().verified_flush()) {
+        unverified_sync_tokens.push_back(resource->GetSyncTokenData());
+      }
     }
   }
 
   // Insert sync point to synchronize the mailbox creation or bound textures.
   gpu::SyncToken new_sync_token;
-  if (gl) {
-    if (!need_synchronization_resources.empty()) {
-      const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
-      gl->OrderingBarrierCHROMIUM();
-      gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
-      unverified_sync_tokens.push_back(new_sync_token.GetData());
-    }
+  if (!need_synchronization_resources.empty()) {
+    DCHECK(delegated_sync_points_required_);
+    DCHECK(gl);
+    const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
+    gl->OrderingBarrierCHROMIUM();
+    gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
+    unverified_sync_tokens.push_back(new_sync_token.GetData());
+  }
 
-    if (!unverified_sync_tokens.empty()) {
-      gl->VerifySyncTokensCHROMIUM(unverified_sync_tokens.data(),
-                                   unverified_sync_tokens.size());
-    }
+  if (!unverified_sync_tokens.empty()) {
+    DCHECK(delegated_sync_points_required_);
+    DCHECK(gl);
+    gl->VerifySyncTokensCHROMIUM(unverified_sync_tokens.data(),
+                                 unverified_sync_tokens.size());
   }
+
+  // Set sync token after verification.
   for (Resource* resource : need_synchronization_resources) {
+    DCHECK(IsGpuResourceType(resource->type));
     resource->UpdateSyncToken(new_sync_token);
     resource->SetSynchronized();
   }
 
   // Transfer Resources
   DCHECK_EQ(resources.size(), resource_ids.size());
   for (size_t i = 0; i < resources.size(); ++i) {
     Resource* source = resources[i];
     const ResourceId id = resource_ids[i];
 
@@ skipping 137 matching lines @@
   for (const auto& children : resources_for_child) {
     ChildMap::iterator child_it = children_.find(children.first);
     DCHECK(child_it != children_.end());
     DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, children.second);
   }
 }
 
 void ResourceProvider::CreateMailboxAndBindResource(
     gpu::gles2::GLES2Interface* gl,
     Resource* resource) {
-  if (resource->type != RESOURCE_TYPE_BITMAP) {
-    if (!resource->mailbox().IsValid()) {
-      LazyCreate(resource);
+  DCHECK(IsGpuResourceType(resource->type));
+  DCHECK(gl);
 
-      gpu::MailboxHolder mailbox_holder;
-      mailbox_holder.texture_target = resource->target;
-      gl->GenMailboxCHROMIUM(mailbox_holder.mailbox.name);
-      gl->ProduceTextureDirectCHROMIUM(resource->gl_id,
-                                       mailbox_holder.texture_target,
-                                       mailbox_holder.mailbox.name);
-      resource->set_mailbox(TextureMailbox(mailbox_holder));
-    }
+  if (!resource->mailbox().IsValid()) {
+    LazyCreate(resource);
 
-    if (resource->image_id && resource->dirty_image) {
-      DCHECK(resource->gl_id);
-      DCHECK(resource->origin == Resource::INTERNAL);
-      BindImageForSampling(resource);
-    }
+    gpu::MailboxHolder mailbox_holder;
+    mailbox_holder.texture_target = resource->target;
+    gl->GenMailboxCHROMIUM(mailbox_holder.mailbox.name);
+    gl->ProduceTextureDirectCHROMIUM(resource->gl_id,
+                                     mailbox_holder.texture_target,
+                                     mailbox_holder.mailbox.name);
+    resource->set_mailbox(TextureMailbox(mailbox_holder));
+  }
+
+  if (resource->image_id && resource->dirty_image) {
+    DCHECK(resource->gl_id);
+    DCHECK(resource->origin == Resource::INTERNAL);
+    BindImageForSampling(resource);
   }
 }
 
 void ResourceProvider::TransferResource(Resource* source,
                                         ResourceId id,
                                         TransferableResource* resource) {
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
   DCHECK(source->origin != Resource::EXTERNAL || source->mailbox().IsValid());
   DCHECK(source->allocated);
@@ skipping 26 matching lines @@
     const ResourceIdArray& unused) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(child_it != children_.end());
   Child* child_info = &child_it->second;
 
   if (unused.empty() && !child_info->marked_for_deletion)
     return;
 
   ReturnedResourceArray to_return;
   to_return.reserve(unused.size());
+  std::vector<ReturnedResource*> need_synchronization_resources;
   std::vector<GLbyte*> unverified_sync_tokens;
 
-  bool need_sync_token = false;
   GLES2Interface* gl = ContextGL();
+
   for (ResourceId local_id : unused) {
     ResourceMap::iterator it = resources_.find(local_id);
     CHECK(it != resources_.end());
     Resource& resource = it->second;
 
     DCHECK(!resource.locked_for_write);
     DCHECK(child_info->parent_to_child_map.count(local_id));
 
     ResourceId child_id = child_info->parent_to_child_map[local_id];
     DCHECK(child_info->child_to_parent_map.count(child_id));
@@ skipping 13 matching lines @@
       // the branch above too, where the resource is locked or still exported.
       if (style != FOR_SHUTDOWN && !child_info->marked_for_deletion) {
         // Defer this resource deletion.
         resource.marked_for_deletion = true;
         continue;
       }
       // We can't postpone the deletion, so we'll have to lose it.
       is_lost = true;
     }
 
-    if (gl && resource.filter != resource.original_filter) {
+    if (IsGpuResourceType(resource.type) &&
+        resource.filter != resource.original_filter) {
       DCHECK(resource.target);
       DCHECK(resource.gl_id);
-
+      DCHECK(gl);
       gl->BindTexture(resource.target, resource.gl_id);
       gl->TexParameteri(resource.target, GL_TEXTURE_MIN_FILTER,
                         resource.original_filter);
       gl->TexParameteri(resource.target, GL_TEXTURE_MAG_FILTER,
                         resource.original_filter);
       resource.SetLocallyUsed();
     }
 
     ReturnedResource returned;
     returned.id = child_id;
-    if (resource.needs_sync_token())
-      need_sync_token = true;
-    else
-      returned.sync_token = resource.mailbox().sync_token();
-
+    returned.sync_token = resource.mailbox().sync_token();
     returned.count = resource.imported_count;
     returned.lost = is_lost;
     to_return.push_back(returned);
 
+    if (IsGpuResourceType(resource.type) && child_info->needs_sync_tokens) {
+      if (resource.needs_sync_token()) {
+        need_synchronization_resources.push_back(&to_return.back());
+      } else if (returned.sync_token.HasData() &&
+                 !returned.sync_token.verified_flush()) {
+        // Before returning any sync tokens, they must be verified.
+        unverified_sync_tokens.push_back(returned.sync_token.GetData());
+      }
+    }
+
     child_info->parent_to_child_map.erase(local_id);
     child_info->child_to_parent_map.erase(child_id);
     resource.imported_count = 0;
     DeleteResourceInternal(it, style);
-
-    // Before returning any sync tokens, they must be verified. Note that we
-    // need to verify the sync token inside of the "to_return" array.
-    if (to_return.back().sync_token.HasData() &&
-        !to_return.back().sync_token.verified_flush()) {
-      unverified_sync_tokens.push_back(to_return.back().sync_token.GetData());
-    }
   }
 
   gpu::SyncToken new_sync_token;
-  if (need_sync_token && child_info->needs_sync_tokens) {
+  if (!need_synchronization_resources.empty()) {
+    DCHECK(child_info->needs_sync_tokens);
     DCHECK(gl);
     const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
     gl->OrderingBarrierCHROMIUM();
     gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
     unverified_sync_tokens.push_back(new_sync_token.GetData());
   }
 
   if (!unverified_sync_tokens.empty()) {
+    DCHECK(child_info->needs_sync_tokens);
     DCHECK(gl);
     gl->VerifySyncTokensCHROMIUM(unverified_sync_tokens.data(),
                                  unverified_sync_tokens.size());
   }
 
-  if (new_sync_token.HasData()) {
-    DCHECK(need_sync_token && child_info->needs_sync_tokens);
-    for (ReturnedResource& returned_resource : to_return) {
-      if (!returned_resource.sync_token.HasData())
-        returned_resource.sync_token = new_sync_token;
-    }
-  }
+  // Set sync token after verification.
+  for (ReturnedResource* returned : need_synchronization_resources)
+    returned->sync_token = new_sync_token;
 
   if (!to_return.empty())
     child_info->return_callback.Run(to_return,
                                     blocking_main_thread_task_runner_);
 
   if (child_info->marked_for_deletion &&
       child_info->parent_to_child_map.empty()) {
     DCHECK(child_info->child_to_parent_map.empty());
     children_.erase(child_it);
   }
@@ skipping 255 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc