Modified old wait sync point functions to also accept new sync tokens.

cc/layers/texture_layer.cc

 // Copyright 2010 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/layers/texture_layer.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/synchronization/lock.h"
@@ skipping 136 matching lines @@
 
 void TextureLayer::SetTextureMailbox(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback) {
   bool requires_commit = true;
   bool allow_mailbox_reuse = false;
   SetTextureMailboxInternal(
       mailbox, release_callback.Pass(), requires_commit, allow_mailbox_reuse);
 }
 
-static void IgnoreReleaseCallback(uint32 sync_point, bool lost) {}
+static void IgnoreReleaseCallback(uint32 sync_point,
+                                  const gpu::SyncToken& sync_token,
+                                  bool lost) {}
 
 void TextureLayer::SetTextureMailboxWithoutReleaseCallback(
     const TextureMailbox& mailbox) {
   // We allow reuse of the mailbox if there is a new sync point signalling new
   // content, and the release callback goes nowhere since we'll be calling it
   // multiple times for the same mailbox.
   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
          !mailbox.Equals(holder_ref_->holder()->mailbox()) ||
-         mailbox.sync_point() != holder_ref_->holder()->mailbox().sync_point());
+         mailbox.sync_point() !=
+             holder_ref_->holder()->mailbox().sync_point() ||
+         mailbox.sync_token() != holder_ref_->holder()->mailbox().sync_token());
   scoped_ptr<SingleReleaseCallback> release;
   bool requires_commit = true;
   bool allow_mailbox_reuse = true;
   if (mailbox.IsValid())
     release = SingleReleaseCallback::Create(base::Bind(&IgnoreReleaseCallback));
   SetTextureMailboxInternal(
       mailbox, release.Pass(), requires_commit, allow_mailbox_reuse);
 }
 
 void TextureLayer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
@@ skipping 84 matching lines @@
   holder_->InternalRelease();
 }
 
 TextureLayer::TextureMailboxHolder::TextureMailboxHolder(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback)
     : internal_references_(0),
       mailbox_(mailbox),
       release_callback_(release_callback.Pass()),
       sync_point_(mailbox.sync_point()),
-      is_lost_(false) {
-}
+      sync_token_(mailbox.sync_token()),
+      is_lost_(false) {}
 
 TextureLayer::TextureMailboxHolder::~TextureMailboxHolder() {
   DCHECK_EQ(0u, internal_references_);
 }
 
 scoped_ptr<TextureLayer::TextureMailboxHolder::MainThreadReference>
 TextureLayer::TextureMailboxHolder::Create(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback) {
   return make_scoped_ptr(new MainThreadReference(
       new TextureMailboxHolder(mailbox, release_callback.Pass())));
 }
 
-void TextureLayer::TextureMailboxHolder::Return(uint32 sync_point,
-                                                bool is_lost) {
+void TextureLayer::TextureMailboxHolder::Return(
+    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
+    bool is_lost) {
   base::AutoLock lock(arguments_lock_);
   sync_point_ = sync_point;
+  sync_token_ = sync_token;
   is_lost_ = is_lost;
 }
 
 scoped_ptr<SingleReleaseCallbackImpl>
 TextureLayer::TextureMailboxHolder::GetCallbackForImplThread() {
   // We can't call GetCallbackForImplThread if we released the main thread
   // reference.
   DCHECK_GT(internal_references_, 0u);
   InternalAddRef();
   return SingleReleaseCallbackImpl::Create(
       base::Bind(&TextureMailboxHolder::ReturnAndReleaseOnImplThread, this));
 }
 
 void TextureLayer::TextureMailboxHolder::InternalAddRef() {
   ++internal_references_;
 }
 
 void TextureLayer::TextureMailboxHolder::InternalRelease() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!--internal_references_) {
-    release_callback_->Run(sync_point_, is_lost_);
+    release_callback_->Run(sync_point_, sync_token_, is_lost_);
     mailbox_ = TextureMailbox();
     release_callback_ = nullptr;
   }
 }
 
 void TextureLayer::TextureMailboxHolder::ReturnAndReleaseOnImplThread(
     uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     bool is_lost,
     BlockingTaskRunner* main_thread_task_runner) {
-  Return(sync_point, is_lost);
+  Return(sync_point, sync_token, is_lost);
   main_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&TextureMailboxHolder::InternalRelease, this));
 }
 
 }  // namespace cc