Added methods to generate sync tokens for resource id(s).

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 735 matching lines @@
                                image_size.width(), image_size.height(), 0,
                                image_bytes, image);
     } else {
       gl->TexSubImage2D(resource->target, 0, 0, 0, image_size.width(),
                         image_size.height(), GLDataFormat(resource->format),
                         GLDataType(resource->format), image);
     }
   }
 }
 
+void ResourceProvider::GenerateSyncTokenForResource(ResourceId resource_id) {

[David Yen, 2016/02/17 21:53:28]

From piman@ (originally inside CopyToResource where I had inserted a fence sync
after every copy):

Most callers are debug/fallback paths and/or relatively rare calls (UI
resources), but one is the video path for software decode, where this would be
called 3 times per video frame (once for each plane). If there are concurrent
rasterization tasks, the ordering barriers can become (or cause) real flushes,
so that would be a regression I think.

Maybe we could make the caller responsible for doing the synchronization, and
provide a SynchronizeResources that could do a single fence/OB and set the token
on all resources?

[David Yen, 2016/02/17 21:54:36]

Done. There are probably other places CopyToResource() is used where this
function needs to be called, but I just added the 2 most obvious ones first.
Once I add in the DCHECK it will be more obvious where else we need to add sync
token generation.

+  Resource* resource = GetResource(resource_id);
+  if (!resource->needs_sync_token())
+    return;
+
+  gpu::SyncToken sync_token;
+  GLES2Interface* gl = ContextGL();
+  DCHECK(gl);
+
+  const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
+  gl->OrderingBarrierCHROMIUM();
+  gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+
+  resource->UpdateSyncToken(sync_token);
+}
+
+void ResourceProvider::GenerateSyncTokenForResources(
+    const ResourceIdArray& resource_ids) {
+  gpu::SyncToken sync_token;
+  bool created_sync_token = false;
+  for (ResourceId id : resource_ids) {
+    Resource* resource = GetResource(id);
+    if (resource->needs_sync_token()) {
+      if (!created_sync_token) {
+        GLES2Interface* gl = ContextGL();
+        DCHECK(gl);
+
+        const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
+        gl->OrderingBarrierCHROMIUM();
+        gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+        created_sync_token = true;
+      }
+
+      resource->UpdateSyncToken(sync_token);
+    }
+  }
+}
+
 ResourceProvider::Resource* ResourceProvider::InsertResource(
     ResourceId id,
     const Resource& resource) {
   std::pair<ResourceMap::iterator, bool> result =
       resources_.insert(ResourceMap::value_type(id, resource));
   DCHECK(result.second);
   return &result.first->second;
 }
 
 ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
@@ skipping 1090 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc