MailboxSync: Imply fence with sync point

gpu/command_buffer/service/mailbox_synchronizer.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_synchronizer.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_implementation.h"
 
+#if !defined(OS_MACOSX)
+#include "ui/gl/gl_fence_egl.h"
+#endif
+
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 MailboxSynchronizer* g_instance = NULL;
 
 }  // anonymous namespace
 
 // static
@@ skipping 107 matching lines @@
 void MailboxSynchronizer::TextureDeleted(Texture* texture) {
   base::AutoLock lock(lock_);
   TextureMap::iterator it = textures_.find(texture);
   if (it != textures_.end()) {
     // TODO: We could avoid the update if this was the last ref.
     UpdateTextureLocked(it->first, it->second);
     textures_.erase(it);
   }
 }
 
-void MailboxSynchronizer::PushTextureUpdates(MailboxManager* manager) {
+void MailboxSynchronizer::PushTextureUpdates(MailboxManager* manager,
+                                             uint32 sync_point) {
   base::AutoLock lock(lock_);
   for (MailboxManager::MailboxToTextureMap::const_iterator texture_it =
            manager->mailbox_to_textures_.begin();
        texture_it != manager->mailbox_to_textures_.end();
        texture_it++) {
     TargetName target_name(texture_it->first.target, texture_it->first.mailbox);
     Texture* texture = texture_it->second->first;
     // TODO(sievers): crbug.com/352274
     // Should probably only fail if it already *has* mipmaps, while allowing
     // incomplete textures here. Also reconsider how to fail otherwise.
@@ skipping 22 matching lines @@
         continue;
 
       linked_ptr<TextureGroup> group = make_linked_ptr(new TextureGroup(
           TextureDefinition(target_name.target, texture, 1, NULL)));
 
       // Unlink other textures from this mailbox in case the name is not new.
       ReassociateMailboxLocked(target_name, group.get());
       textures_.insert(std::make_pair(texture, TextureVersion(group)));
     }
   }
+
+  CreateFenceLocked(sync_point);
+}
+
+void MailboxSynchronizer::CreateFenceLocked(uint32 sync_point) {
+  lock_.AssertAcquired();
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationMockGL)
+    return;
+
+  if (sync_point) {
+    while (!sync_points_.empty() &&
+           sync_points_.front()->second->HasCompleted()) {
+      sync_point_to_fence_.erase(sync_points_.front());
+      sync_points_.pop();
+    }
+#if !defined(OS_MACOSX)
+    // Need to use EGL fences since we are likely not in a single share group.
+    linked_ptr<gfx::GLFence> fence(make_linked_ptr(new gfx::GLFenceEGL(true)));
+#endif
+    if (fence.get()) {
+      std::pair<SyncPointToFenceMap::iterator, bool> result =
+          sync_point_to_fence_.insert(std::make_pair(sync_point, fence));
+      DCHECK(result.second);
+      sync_points_.push(result.first);
+    }
+    DCHECK(sync_points_.size() == sync_point_to_fence_.size());
+  }
 }
 
 void MailboxSynchronizer::UpdateTextureLocked(Texture* texture,
                                               TextureVersion& texture_version) {
   lock_.AssertAcquired();
   gfx::GLImage* gl_image = texture->GetLevelImage(texture->target(), 0);
   TextureGroup* group = texture_version.group.get();
   scoped_refptr<NativeImageBuffer> image_buffer = group->definition.image();
 
   // Make sure we don't clobber with an older version
   if (!group->definition.IsOlderThan(texture_version.version))
     return;
 
   // Also don't push redundant updates. Note that it would break the
   // versioning.
   if (group->definition.Matches(texture))
     return;
 
   if (gl_image && !image_buffer->IsClient(gl_image)) {
     LOG(ERROR) << "MailboxSync: Incompatible attachment";
     return;
   }
 
   group->definition = TextureDefinition(texture->target(),
                                         texture,
                                         ++texture_version.version,
                                         gl_image ? image_buffer : NULL);
 }
 
-void MailboxSynchronizer::PullTextureUpdates(MailboxManager* manager) {
+void MailboxSynchronizer::AcquireFenceLocked(uint32 sync_point) {
+  lock_.AssertAcquired();
+  SyncPointToFenceMap::iterator fence_it =
+      sync_point_to_fence_.find(sync_point);
+  if (fence_it != sync_point_to_fence_.end()) {
+    fence_it->second->ServerWait();
+  }
+}
+
+void MailboxSynchronizer::PullTextureUpdates(MailboxManager* manager,
+                                             uint32 sync_point) {
   base::AutoLock lock(lock_);
+  AcquireFenceLocked(sync_point);
+
   for (MailboxManager::MailboxToTextureMap::const_iterator texture_it =
            manager->mailbox_to_textures_.begin();
        texture_it != manager->mailbox_to_textures_.end();
        texture_it++) {
     Texture* texture = texture_it->second->first;
     TextureMap::iterator it = textures_.find(texture);
     if (it != textures_.end()) {
       TextureDefinition& definition = it->second.group->definition;
       if (it->second.version == definition.version() ||
           definition.IsOlderThan(it->second.version))
         continue;
       it->second.version = definition.version();
       definition.UpdateTexture(texture);
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu