Use flat_set for ResourceIdSet

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 1605 matching lines @@
       resource->wants_promotion_hint = it->wants_promotion_hint;
       if (resource->wants_promotion_hint)
         wants_promotion_hints_set_.insert(local_id);
 #endif
       resource->color_space = it->color_space;
     }
     resource->child_id = child;
     // Don't allocate a texture for a child.
     resource->allocated = true;
     resource->imported_count = 1;
-    child_info.parent_to_child_map[local_id] = it->id;
+    resource->id_in_child = 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());
 
   ChildMap::iterator child_it = children_.find(child);
@@ skipping 191 matching lines @@
   std::vector<GLbyte*> unverified_sync_tokens;
 
   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];
+    ResourceId child_id = resource.id_in_child;
     DCHECK(child_info->child_to_parent_map.count(child_id));
 
     bool is_lost = resource.lost ||
                    (IsGpuResourceType(resource.type) && lost_context_provider_);
     if (resource.exported_count > 0 || resource.lock_for_read_count > 0) {
       if (style != FOR_SHUTDOWN) {
         // Defer this resource deletion.
         resource.marked_for_deletion = true;
         continue;
       }
@@ skipping 34 matching lines @@
     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);
   }
 
   gpu::SyncToken new_sync_token;
   if (!need_synchronization_resources.empty()) {
     DCHECK(child_info->needs_sync_tokens);
     DCHECK(gl);
     const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
@@ skipping 11 matching lines @@
 
   // 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());
+      child_info->child_to_parent_map.empty()) {
     children_.erase(child_it);
   }
 }
 
 GLenum ResourceProvider::BindForSampling(ResourceId resource_id,
                                          GLenum unit,
                                          GLenum filter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   GLES2Interface* gl = ContextGL();
   ResourceMap::iterator it = resources_.find(resource_id);
@@ skipping 258 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc