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

cc/resources/resource_provider_unittest.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 <algorithm>
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 25 matching lines @@
 using testing::Mock;
 using testing::NiceMock;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::StrictMock;
 using testing::_;
 
 namespace cc {
 namespace {
 
-static void EmptyReleaseCallback(uint32 sync_point,
-                                 bool lost_resource,
-                                 BlockingTaskRunner* main_thread_task_runner) {
+MATCHER_P(MatchesSyncToken, sync_token, "") {
+  gpu::SyncToken other;
+  memcpy(&other, arg, sizeof(other));
+  return other == sync_token;
 }
 
+static void EmptyReleaseCallback(const gpu::SyncToken& sync_token,
+                                 bool lost_resource,
+                                 BlockingTaskRunner* main_thread_task_runner) {}
+
 static void ReleaseCallback(
-    uint32* release_sync_point,
+    gpu::SyncToken* release_sync_token,
     bool* release_lost_resource,
     BlockingTaskRunner** release_main_thread_task_runner,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
-  *release_sync_point = sync_point;
+  *release_sync_token = sync_token;
   *release_lost_resource = lost_resource;
   *release_main_thread_task_runner = main_thread_task_runner;
 }
 
 static void SharedBitmapReleaseCallback(
     scoped_ptr<SharedBitmap> bitmap,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     bool lost_resource,
-    BlockingTaskRunner* main_thread_task_runner) {
-}
+    BlockingTaskRunner* main_thread_task_runner) {}
 
 static void ReleaseSharedBitmapCallback(
     scoped_ptr<SharedBitmap> shared_bitmap,
     bool* release_called,
-    uint32* release_sync_point,
+    gpu::SyncToken* release_sync_token,
     bool* lost_resource_result,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
   *release_called = true;
-  *release_sync_point = sync_point;
+  *release_sync_token = sync_token;
   *lost_resource_result = lost_resource;
 }
 
 static scoped_ptr<SharedBitmap> CreateAndFillSharedBitmap(
     SharedBitmapManager* manager,
     const gfx::Size& size,
     uint32_t value) {
   scoped_ptr<SharedBitmap> shared_bitmap = manager->AllocateSharedBitmap(size);
   CHECK(shared_bitmap);
   uint32_t* pixels = reinterpret_cast<uint32_t*>(shared_bitmap->pixels());
   CHECK(pixels);
   std::fill_n(pixels, size.GetArea(), value);
   return shared_bitmap.Pass();
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
   MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));
-  MOCK_METHOD1(waitSyncPoint, void(GLuint sync_point));
+  MOCK_METHOD1(waitSyncToken, void(const GLbyte* sync_token));
   MOCK_METHOD0(insertSyncPoint, GLuint(void));
   MOCK_METHOD3(produceTextureDirectCHROMIUM,
                void(GLuint texture, GLenum target, const GLbyte* mailbox));
   MOCK_METHOD2(createAndConsumeTextureCHROMIUM,
                unsigned(GLenum target, const GLbyte* mailbox));
 
   // Force all textures to be consecutive numbers starting at "1",
   // so we easily can test for them.
   GLuint NextTextureId() override {
     base::AutoLock lock(namespace_->lock);
@@ skipping 12 matching lines @@
 
   uint32 InsertSyncPoint() { return next_sync_point_++; }
 
   void GenMailbox(GLbyte* mailbox) {
     memset(mailbox, 0, GL_MAILBOX_SIZE_CHROMIUM);
     memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_));
     ++next_mailbox_;
   }
 
   void ProduceTexture(const GLbyte* mailbox_name,
-                      uint32 sync_point,
+                      const gpu::SyncToken& sync_token,
                       scoped_refptr<TestTexture> texture) {
+    uint32_t sync_point = static_cast<uint32_t>(sync_token.release_count());

[dcheng, 2015/11/03 07:39:28]

Nit: just make this a uint64_t instead of casting?

[David Yen, 2015/11/03 18:09:27]

sync_point_for_mail_box takes a uint32, I'd rather minimize changes here. All of
this code is about to be deleted though once we switch to real sync tokens.

+
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     ASSERT_TRUE(mailbox && mailbox < next_mailbox_);
     textures_[mailbox] = texture;
     ASSERT_LT(sync_point_for_mailbox_[mailbox], sync_point);
     sync_point_for_mailbox_[mailbox] = sync_point;
   }
 
   scoped_refptr<TestTexture> ConsumeTexture(const GLbyte* mailbox_name,
-                                            uint32 sync_point) {
+                                            const gpu::SyncToken& sync_token) {
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     DCHECK(mailbox && mailbox < next_mailbox_);
 
     // If the latest sync point the context has waited on is before the sync
     // point for when the mailbox was set, pretend we never saw that
     // ProduceTexture.
-    if (sync_point_for_mailbox_[mailbox] > sync_point) {
+    if (sync_point_for_mailbox_[mailbox] > sync_token.release_count()) {
       NOTREACHED();
       return scoped_refptr<TestTexture>();
     }
     return textures_[mailbox];
   }
 
  private:
   ContextSharedData() : next_sync_point_(1), next_mailbox_(1) {}
 
   uint32 next_sync_point_;
@@ skipping 11 matching lines @@
   }
 
   GLuint insertSyncPoint() override {
     uint32 sync_point = shared_data_->InsertSyncPoint();
     // Commit the produceTextureCHROMIUM calls at this point, so that
     // they're associated with the sync point.
     for (PendingProduceTextureList::iterator it =
              pending_produce_textures_.begin();
          it != pending_produce_textures_.end();
          ++it) {
-      shared_data_->ProduceTexture(
-          (*it)->mailbox, sync_point, (*it)->texture);
+      shared_data_->ProduceTexture((*it)->mailbox, gpu::SyncToken(sync_point),
+                                   (*it)->texture);
     }
     pending_produce_textures_.clear();
     return sync_point;
   }
 
-  void waitSyncPoint(GLuint sync_point) override {
-    last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
+  void waitSyncToken(const GLbyte* sync_token) override {
+    gpu::SyncToken sync_token_data;
+    if (sync_token)
+      memcpy(&sync_token_data, sync_token, sizeof(sync_token_data));
+
+    if (sync_token_data.release_count() >
+        last_waited_sync_token_.release_count()) {
+      last_waited_sync_token_ = sync_token_data;
+    }
   }
 
-  unsigned last_waited_sync_point() const { return last_waited_sync_point_; }
+  const gpu::SyncToken& last_waited_sync_token() const {
+    return last_waited_sync_token_;
+  }
 
   void texStorage2DEXT(GLenum target,
                        GLint levels,
                        GLuint internalformat,
                        GLint width,
                        GLint height) override {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_EQ(1, levels);
     GLenum format = GL_RGBA;
@@ skipping 65 matching lines @@
     base::AutoLock lock_for_texture_access(namespace_->lock);
     pending->texture = UnboundTexture(texture);
     pending_produce_textures_.push_back(pending.Pass());
   }
 
   GLuint createAndConsumeTextureCHROMIUM(GLenum target,
                                          const GLbyte* mailbox) override {
     GLuint texture_id = createTexture();
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture =
-        shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_);
+        shared_data_->ConsumeTexture(mailbox, last_waited_sync_token_);
     namespace_->textures.Replace(texture_id, texture);
     return texture_id;
   }
 
   void GetPixels(const gfx::Size& size,
                  ResourceFormat format,
                  uint8_t* pixels) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture = BoundTexture(GL_TEXTURE_2D);
     ASSERT_EQ(texture->size, size);
     ASSERT_EQ(texture->format, format);
     memcpy(pixels, texture->data.get(), TextureSizeBytes(size, format));
   }
 
  protected:
   explicit ResourceProviderContext(ContextSharedData* shared_data)
-      : shared_data_(shared_data),
-        last_waited_sync_point_(0) {}
+      : shared_data_(shared_data) {}
 
  private:
   void AllocateTexture(const gfx::Size& size, GLenum format) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     ResourceFormat texture_format = RGBA_8888;
     switch (format) {
       case GL_RGBA:
         texture_format = RGBA_8888;
         break;
       case GL_BGRA_EXT:
@@ skipping 28 matching lines @@
       src += in_pitch;
     }
   }
 
   struct PendingProduceTexture {
     GLbyte mailbox[GL_MAILBOX_SIZE_CHROMIUM];
     scoped_refptr<TestTexture> texture;
   };
   typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
   ContextSharedData* shared_data_;
-  GLuint last_waited_sync_point_;
+  gpu::SyncToken last_waited_sync_token_;
   PendingProduceTextureList pending_produce_textures_;
 };
 
 void GetResourcePixels(ResourceProvider* resource_provider,
                        ResourceProviderContext* context,
                        ResourceId id,
                        const gfx::Size& size,
                        ResourceFormat format,
                        uint8_t* pixels) {
-  resource_provider->WaitSyncPointIfNeeded(id);
+  resource_provider->WaitSyncTokenIfNeeded(id);
   switch (resource_provider->default_resource_type()) {
     case ResourceProvider::RESOURCE_TYPE_GL_TEXTURE: {
       ResourceProvider::ScopedReadLockGL lock_gl(resource_provider, id);
       ASSERT_NE(0U, lock_gl.texture_id());
       context->bindTexture(GL_TEXTURE_2D, lock_gl.texture_id());
       context->GetPixels(size, format, pixels);
       break;
     }
     case ResourceProvider::RESOURCE_TYPE_BITMAP: {
       ResourceProvider::ScopedReadLockSoftware lock_software(resource_provider,
                                                              id);
       memcpy(pixels,
              lock_software.sk_bitmap()->getPixels(),
              lock_software.sk_bitmap()->getSize());
       break;
     }
   }
 }
 
 class ResourceProviderTest
     : public testing::TestWithParam<ResourceProvider::ResourceType> {
  public:
-  explicit ResourceProviderTest(bool child_needs_sync_point)
+  explicit ResourceProviderTest(bool child_needs_sync_token)
       : shared_data_(ContextSharedData::Create()),
         context3d_(NULL),
         child_context_(NULL),
         main_thread_task_runner_(BlockingTaskRunner::Create(NULL)) {
     switch (GetParam()) {
       case ResourceProvider::RESOURCE_TYPE_GL_TEXTURE: {
         scoped_ptr<ResourceProviderContext> context3d(
             ResourceProviderContext::Create(shared_data_.get()));
         context3d_ = context3d.get();
 
         scoped_refptr<TestContextProvider> context_provider =
             TestContextProvider::Create(context3d.Pass());
 
         output_surface_ = FakeOutputSurface::Create3d(context_provider);
 
         scoped_ptr<ResourceProviderContext> child_context_owned =
             ResourceProviderContext::Create(shared_data_.get());
         child_context_ = child_context_owned.get();
-        if (child_needs_sync_point) {
+        if (child_needs_sync_token) {
           child_output_surface_ =
               FakeOutputSurface::Create3d(child_context_owned.Pass());
         } else {
           child_output_surface_ = FakeOutputSurface::CreateNoRequireSyncPoint(
               child_context_owned.Pass());
         }
         break;
       }
       case ResourceProvider::RESOURCE_TYPE_BITMAP:
         output_surface_ = FakeOutputSurface::CreateSoftware(
@@ skipping 32 matching lines @@
 
   static void SetResourceFilter(ResourceProvider* resource_provider,
                                 ResourceId id,
                                 GLenum filter) {
     ResourceProvider::ScopedSamplerGL sampler(
         resource_provider, id, GL_TEXTURE_2D, filter);
   }
 
   ResourceProviderContext* context() { return context3d_; }
 
-  ResourceId CreateChildMailbox(uint32* release_sync_point,
+  ResourceId CreateChildMailbox(gpu::SyncToken* release_sync_token,
                                 bool* lost_resource,
                                 bool* release_called,
-                                uint32* sync_point) {
+                                gpu::SyncToken* sync_token) {
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
       unsigned texture = child_context_->createTexture();
       gpu::Mailbox gpu_mailbox;
       child_context_->genMailboxCHROMIUM(gpu_mailbox.name);
       child_context_->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D,
                                                    gpu_mailbox.name);
-      *sync_point = child_context_->insertSyncPoint();
-      EXPECT_LT(0u, *sync_point);
+      *sync_token = gpu::SyncToken(child_context_->insertSyncPoint());
+      EXPECT_TRUE(sync_token->HasData());
 
       scoped_ptr<SharedBitmap> shared_bitmap;
       scoped_ptr<SingleReleaseCallbackImpl> callback =
           SingleReleaseCallbackImpl::Create(base::Bind(
               ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap),
-              release_called, release_sync_point, lost_resource));
+              release_called, release_sync_token, lost_resource));
       return child_resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(gpu_mailbox, GL_TEXTURE_2D, *sync_point),
+          TextureMailbox(gpu_mailbox, *sync_token, GL_TEXTURE_2D),
           callback.Pass());
     } else {
       gfx::Size size(64, 64);
       scoped_ptr<SharedBitmap> shared_bitmap(
           CreateAndFillSharedBitmap(shared_bitmap_manager_.get(), size, 0));
 
       SharedBitmap* shared_bitmap_ptr = shared_bitmap.get();
       scoped_ptr<SingleReleaseCallbackImpl> callback =
           SingleReleaseCallbackImpl::Create(base::Bind(
               ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap),
-              release_called, release_sync_point, lost_resource));
+              release_called, release_sync_token, lost_resource));
       return child_resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(shared_bitmap_ptr, size), callback.Pass());
     }
   }
 
  public:
   static std::vector<unsigned> use_image_texture_targets() {
     return use_image_texture_targets_;
   }
 
@@ skipping 109 matching lines @@
         child_resource_provider_.get(), id3);
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
 
   GLuint external_texture_id = child_context_->createExternalTexture();
 
   gpu::Mailbox external_mailbox;
   child_context_->genMailboxCHROMIUM(external_mailbox.name);
   child_context_->produceTextureDirectCHROMIUM(
       external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
-  const GLuint external_sync_point = child_context_->insertSyncPoint();
+  const gpu::SyncToken external_sync_token(child_context_->insertSyncPoint());
   ResourceId id4 = child_resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(external_mailbox, GL_TEXTURE_EXTERNAL_OES,
-                     external_sync_point),
+      TextureMailbox(external_mailbox, external_sync_token,
+                     GL_TEXTURE_EXTERNAL_OES),
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
     resource_ids_to_transfer.push_back(id4);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(4u, list.size());
-    EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
-    EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
-    EXPECT_EQ(list[0].mailbox_holder.sync_point,
-              list[1].mailbox_holder.sync_point);
-    EXPECT_NE(0u, list[2].mailbox_holder.sync_point);
-    EXPECT_EQ(list[0].mailbox_holder.sync_point,
-              list[2].mailbox_holder.sync_point);
-    EXPECT_EQ(external_sync_point, list[3].mailbox_holder.sync_point);
+    EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
+    EXPECT_TRUE(list[1].mailbox_holder.sync_token.HasData());
+    EXPECT_EQ(list[0].mailbox_holder.sync_token,
+              list[1].mailbox_holder.sync_token);
+    EXPECT_TRUE(list[2].mailbox_holder.sync_token.HasData());
+    EXPECT_EQ(list[0].mailbox_holder.sync_token,
+              list[2].mailbox_holder.sync_token);
+    EXPECT_EQ(external_sync_token, list[3].mailbox_holder.sync_token);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[0].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[1].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[2].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES),
               list[3].mailbox_holder.texture_target);
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
     resource_provider_->ReceiveFromChild(child_id, list);
-    EXPECT_NE(list[0].mailbox_holder.sync_point,
-              context3d_->last_waited_sync_point());
+    EXPECT_NE(list[0].mailbox_holder.sync_token,
+              context3d_->last_waited_sync_token());
     {
-      resource_provider_->WaitSyncPointIfNeeded(list[0].id);
+      resource_provider_->WaitSyncTokenIfNeeded(list[0].id);
       ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                               list[0].id);
     }
-    EXPECT_EQ(list[0].mailbox_holder.sync_point,
-              context3d_->last_waited_sync_point());
+    EXPECT_EQ(list[0].mailbox_holder.sync_token,
+              context3d_->last_waited_sync_token());
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_ids_to_receive.insert(id3);
     resource_ids_to_receive.insert(id4);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
 
   EXPECT_EQ(4u, resource_provider_->num_resources());
@@ skipping 52 matching lines @@
   }
   {
     EXPECT_EQ(0u, returned_to_child.size());
 
     // Transfer resources back from the parent to the child. Set no resources as
     // being in use.
     ResourceProvider::ResourceIdSet no_resources;
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     ASSERT_EQ(4u, returned_to_child.size());
-    EXPECT_NE(0u, returned_to_child[0].sync_point);
-    EXPECT_NE(0u, returned_to_child[1].sync_point);
-    EXPECT_NE(0u, returned_to_child[2].sync_point);
-    EXPECT_NE(0u, returned_to_child[3].sync_point);
+    EXPECT_TRUE(returned_to_child[0].sync_token.HasData());
+    EXPECT_TRUE(returned_to_child[1].sync_token.HasData());
+    EXPECT_TRUE(returned_to_child[2].sync_token.HasData());
+    EXPECT_TRUE(returned_to_child[3].sync_token.HasData());
     EXPECT_FALSE(returned_to_child[0].lost);
     EXPECT_FALSE(returned_to_child[1].lost);
     EXPECT_FALSE(returned_to_child[2].lost);
     EXPECT_FALSE(returned_to_child[3].lost);
     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
     returned_to_child.clear();
   }
   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id1));
   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id2));
   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id3));
   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id4));
 
   {
-    child_resource_provider_->WaitSyncPointIfNeeded(id1);
+    child_resource_provider_->WaitSyncTokenIfNeeded(id1);
     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
                                             id1);
     ASSERT_NE(0U, lock.texture_id());
     child_context_->bindTexture(GL_TEXTURE_2D, lock.texture_id());
     child_context_->GetPixels(size, format, result);
     EXPECT_EQ(0, memcmp(data1, result, pixel_size));
   }
   {
-    child_resource_provider_->WaitSyncPointIfNeeded(id2);
+    child_resource_provider_->WaitSyncTokenIfNeeded(id2);
     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
                                             id2);
     ASSERT_NE(0U, lock.texture_id());
     child_context_->bindTexture(GL_TEXTURE_2D, lock.texture_id());
     child_context_->GetPixels(size, format, result);
     EXPECT_EQ(0, memcmp(data2, result, pixel_size));
   }
   {
-    child_resource_provider_->WaitSyncPointIfNeeded(id3);
+    child_resource_provider_->WaitSyncTokenIfNeeded(id3);
     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
                                             id3);
     ASSERT_NE(0U, lock.texture_id());
     child_context_->bindTexture(GL_TEXTURE_2D, lock.texture_id());
   }
   {
     // Transfer resources to the parent again.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
     resource_ids_to_transfer.push_back(id4);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(4u, list.size());
     EXPECT_EQ(id1, list[0].id);
     EXPECT_EQ(id2, list[1].id);
     EXPECT_EQ(id3, list[2].id);
     EXPECT_EQ(id4, list[3].id);
-    EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
-    EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
-    EXPECT_NE(0u, list[2].mailbox_holder.sync_point);
-    EXPECT_NE(0u, list[3].mailbox_holder.sync_point);
+    EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
+    EXPECT_TRUE(list[1].mailbox_holder.sync_token.HasData());
+    EXPECT_TRUE(list[2].mailbox_holder.sync_token.HasData());
+    EXPECT_TRUE(list[3].mailbox_holder.sync_token.HasData());
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[0].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[1].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[2].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES),
               list[3].mailbox_holder.texture_target);
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
     resource_provider_->ReceiveFromChild(child_id, list);
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_ids_to_receive.insert(id3);
     resource_ids_to_receive.insert(id4);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
 
   EXPECT_EQ(0u, returned_to_child.size());
 
   EXPECT_EQ(4u, resource_provider_->num_resources());
   resource_provider_->DestroyChild(child_id);
   EXPECT_EQ(0u, resource_provider_->num_resources());
 
   ASSERT_EQ(4u, returned_to_child.size());
-  EXPECT_NE(0u, returned_to_child[0].sync_point);
-  EXPECT_NE(0u, returned_to_child[1].sync_point);
-  EXPECT_NE(0u, returned_to_child[2].sync_point);
-  EXPECT_NE(0u, returned_to_child[3].sync_point);
+  EXPECT_TRUE(returned_to_child[0].sync_token.HasData());
+  EXPECT_TRUE(returned_to_child[1].sync_token.HasData());
+  EXPECT_TRUE(returned_to_child[2].sync_token.HasData());
+  EXPECT_TRUE(returned_to_child[3].sync_token.HasData());
   EXPECT_FALSE(returned_to_child[0].lost);
   EXPECT_FALSE(returned_to_child[1].lost);
   EXPECT_FALSE(returned_to_child[2].lost);
   EXPECT_FALSE(returned_to_child[3].lost);
 }
 
-class ResourceProviderTestNoSyncPoint : public ResourceProviderTest {
+class ResourceProviderTestNoSyncToken : public ResourceProviderTest {
  public:
-  ResourceProviderTestNoSyncPoint() : ResourceProviderTest(false) {
+  ResourceProviderTestNoSyncToken() : ResourceProviderTest(false) {
     EXPECT_EQ(ResourceProvider::RESOURCE_TYPE_GL_TEXTURE, GetParam());
   }
 };
 
-TEST_P(ResourceProviderTestNoSyncPoint, TransferGLResources) {
+TEST_P(ResourceProviderTestNoSyncToken, TransferGLResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id1 = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
 
   ResourceId id2 = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   {
     // Ensure locking the memory buffer doesn't create an unnecessary sync
     // point.
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         child_resource_provider_.get(), id2);
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
 
   GLuint external_texture_id = child_context_->createExternalTexture();
 
   // A sync point is specified directly and should be used.
   gpu::Mailbox external_mailbox;
   child_context_->genMailboxCHROMIUM(external_mailbox.name);
   child_context_->produceTextureDirectCHROMIUM(
       external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
-  const GLuint external_sync_point = child_context_->insertSyncPoint();
+  const gpu::SyncToken external_sync_token(child_context_->insertSyncPoint());
   ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(external_mailbox, GL_TEXTURE_EXTERNAL_OES,
-                     external_sync_point),
+      TextureMailbox(external_mailbox, external_sync_token,
+                     GL_TEXTURE_EXTERNAL_OES),
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
-  resource_provider_->SetChildNeedsSyncPoints(child_id, false);
+  resource_provider_->SetChildNeedsSyncTokens(child_id, false);
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(3u, list.size());
     // Standard resources shouldn't require creating and sending a sync point.
-    EXPECT_EQ(0u, list[0].mailbox_holder.sync_point);
-    EXPECT_EQ(0u, list[1].mailbox_holder.sync_point);
+    EXPECT_FALSE(list[0].mailbox_holder.sync_token.HasData());
+    EXPECT_FALSE(list[1].mailbox_holder.sync_token.HasData());
     // A given sync point should be passed through.
-    EXPECT_EQ(external_sync_point, list[2].mailbox_holder.sync_point);
+    EXPECT_EQ(external_sync_token, list[2].mailbox_holder.sync_token);
     resource_provider_->ReceiveFromChild(child_id, list);
 
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_ids_to_receive.insert(id3);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
 
   {
     EXPECT_EQ(0u, returned_to_child.size());
 
     // Transfer resources back from the parent to the child. Set no resources as
     // being in use.
     ResourceProvider::ResourceIdSet no_resources;
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     ASSERT_EQ(3u, returned_to_child.size());
-    std::map<ResourceId, unsigned int> returned_sync_points;
+    std::map<ResourceId, gpu::SyncToken> returned_sync_tokens;
     for (const auto& returned : returned_to_child)
-      returned_sync_points[returned.id] = returned.sync_point;
+      returned_sync_tokens[returned.id] = returned.sync_token;
 
-    EXPECT_TRUE(returned_sync_points.find(id1) != returned_sync_points.end());
+    ASSERT_TRUE(returned_sync_tokens.find(id1) != returned_sync_tokens.end());
     // No new sync point should be created transferring back.
-    EXPECT_TRUE(returned_sync_points.find(id1) != returned_sync_points.end());
-    EXPECT_EQ(0u, returned_sync_points[id1]);
-    EXPECT_TRUE(returned_sync_points.find(id2) != returned_sync_points.end());
-    EXPECT_EQ(0u, returned_sync_points[id2]);
+    ASSERT_TRUE(returned_sync_tokens.find(id1) != returned_sync_tokens.end());
+    EXPECT_FALSE(returned_sync_tokens[id1].HasData());
+    ASSERT_TRUE(returned_sync_tokens.find(id2) != returned_sync_tokens.end());
+    EXPECT_FALSE(returned_sync_tokens[id2].HasData());
     // Original sync point given should be returned.
-    EXPECT_TRUE(returned_sync_points.find(id3) != returned_sync_points.end());
-    EXPECT_EQ(external_sync_point, returned_sync_points[id3]);
+    ASSERT_TRUE(returned_sync_tokens.find(id3) != returned_sync_tokens.end());
+    EXPECT_EQ(external_sync_token, returned_sync_tokens[id3]);
     EXPECT_FALSE(returned_to_child[0].lost);
     EXPECT_FALSE(returned_to_child[1].lost);
     EXPECT_FALSE(returned_to_child[2].lost);
     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
     returned_to_child.clear();
   }
 
   resource_provider_->DestroyChild(child_id);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
-    ResourceProviderTestNoSyncPoint,
+    ResourceProviderTestNoSyncToken,
     ::testing::Values(ResourceProvider::RESOURCE_TYPE_GL_TEXTURE));
 
 TEST_P(ResourceProviderTest, ReadLockCountStopsReturnToChildOrDelete) {
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   ResourceId id1 = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 
     resource_provider_->ReceiveFromChild(child_id, list);
 
-    resource_provider_->WaitSyncPointIfNeeded(list[0].id);
+    resource_provider_->WaitSyncTokenIfNeeded(list[0].id);
     ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                             list[0].id);
 
     resource_provider_->DeclareUsedResourcesFromChild(
         child_id, ResourceProvider::ResourceIdSet());
     EXPECT_EQ(0u, returned_to_child.size());
   }
 
   EXPECT_EQ(1u, returned_to_child.size());
   child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
 
   {
-    child_resource_provider_->WaitSyncPointIfNeeded(id1);
+    child_resource_provider_->WaitSyncTokenIfNeeded(id1);
     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
                                             id1);
     child_resource_provider_->DeleteResource(id1);
     EXPECT_EQ(1u, child_resource_provider_->num_resources());
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
   }
 
   EXPECT_EQ(0u, child_resource_provider_->num_resources());
   resource_provider_->DestroyChild(child_id);
 }
@@ skipping 36 matching lines @@
   ASSERT_EQ(1u, list.size());
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
   EXPECT_TRUE(list[0].read_lock_fences_enabled);
 
   resource_provider_->ReceiveFromChild(child_id, list);
 
   scoped_refptr<TestFence> fence(new TestFence);
   resource_provider_->SetReadLockFence(fence.get());
   {
     unsigned parent_id = list.front().id;
-    resource_provider_->WaitSyncPointIfNeeded(parent_id);
+    resource_provider_->WaitSyncTokenIfNeeded(parent_id);
     ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                             parent_id);
   }
   resource_provider_->DeclareUsedResourcesFromChild(
       child_id, ResourceProvider::ResourceIdSet());
   EXPECT_EQ(0u, returned_to_child.size());
 
   resource_provider_->DeclareUsedResourcesFromChild(
       child_id, ResourceProvider::ResourceIdSet());
   EXPECT_EQ(0u, returned_to_child.size());
@@ skipping 39 matching lines @@
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
 
   resource_provider_->ReceiveFromChild(child_id, list);
 
   scoped_refptr<TestFence> fence(new TestFence);
   resource_provider_->SetReadLockFence(fence.get());
   {
     for (size_t i = 0; i < list.size(); i++) {
       unsigned parent_id = list[i].id;
-      resource_provider_->WaitSyncPointIfNeeded(parent_id);
+      resource_provider_->WaitSyncTokenIfNeeded(parent_id);
       ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                               parent_id);
     }
   }
   EXPECT_EQ(0u, returned_to_child.size());
 
   EXPECT_EQ(2u, resource_provider_->num_resources());
 
   resource_provider_->DestroyChild(child_id);
 
@@ skipping 41 matching lines @@
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
 
   resource_provider_->ReceiveFromChild(child_id, list);
 
   scoped_refptr<TestFence> fence(new TestFence);
   resource_provider_->SetReadLockFence(fence.get());
   {
     for (size_t i = 0; i < list.size(); i++) {
       unsigned parent_id = list[i].id;
-      resource_provider_->WaitSyncPointIfNeeded(parent_id);
+      resource_provider_->WaitSyncTokenIfNeeded(parent_id);
       ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                               parent_id);
     }
   }
   EXPECT_EQ(0u, returned_to_child.size());
 
   EXPECT_EQ(2u, resource_provider_->num_resources());
   resource_provider_->DidLoseOutputSurface();
   resource_provider_ = nullptr;
 
@@ skipping 36 matching lines @@
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(3u, list.size());
-    EXPECT_EQ(0u, list[0].mailbox_holder.sync_point);
-    EXPECT_EQ(0u, list[1].mailbox_holder.sync_point);
-    EXPECT_EQ(0u, list[2].mailbox_holder.sync_point);
+    EXPECT_FALSE(list[0].mailbox_holder.sync_token.HasData());
+    EXPECT_FALSE(list[1].mailbox_holder.sync_token.HasData());
+    EXPECT_FALSE(list[2].mailbox_holder.sync_token.HasData());
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
     resource_provider_->ReceiveFromChild(child_id, list);
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_ids_to_receive.insert(id3);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
@@ skipping 43 matching lines @@
   }
   {
     EXPECT_EQ(0u, returned_to_child.size());
 
     // Transfer resources back from the parent to the child. Set no resources as
     // being in use.
     ResourceProvider::ResourceIdSet no_resources;
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     ASSERT_EQ(3u, returned_to_child.size());
-    EXPECT_EQ(0u, returned_to_child[0].sync_point);
-    EXPECT_EQ(0u, returned_to_child[1].sync_point);
-    EXPECT_EQ(0u, returned_to_child[2].sync_point);
+    EXPECT_FALSE(returned_to_child[0].sync_token.HasData());
+    EXPECT_FALSE(returned_to_child[1].sync_token.HasData());
+    EXPECT_FALSE(returned_to_child[2].sync_token.HasData());
     std::set<ResourceId> expected_ids;
     expected_ids.insert(id1);
     expected_ids.insert(id2);
     expected_ids.insert(id3);
     std::set<ResourceId> returned_ids;
     for (unsigned i = 0; i < 3; i++)
       returned_ids.insert(returned_to_child[i].id);
     EXPECT_EQ(expected_ids, returned_ids);
     EXPECT_FALSE(returned_to_child[0].lost);
     EXPECT_FALSE(returned_to_child[1].lost);
@@ skipping 46 matching lines @@
                                                       resource_ids_to_receive);
   }
 
   EXPECT_EQ(0u, returned_to_child.size());
 
   EXPECT_EQ(3u, resource_provider_->num_resources());
   resource_provider_->DestroyChild(child_id);
   EXPECT_EQ(0u, resource_provider_->num_resources());
 
   ASSERT_EQ(3u, returned_to_child.size());
-  EXPECT_EQ(0u, returned_to_child[0].sync_point);
-  EXPECT_EQ(0u, returned_to_child[1].sync_point);
-  EXPECT_EQ(0u, returned_to_child[2].sync_point);
+  EXPECT_FALSE(returned_to_child[0].sync_token.HasData());
+  EXPECT_FALSE(returned_to_child[1].sync_token.HasData());
+  EXPECT_FALSE(returned_to_child[2].sync_token.HasData());
   std::set<ResourceId> expected_ids;
   expected_ids.insert(id1);
   expected_ids.insert(id2);
   expected_ids.insert(id3);
   std::set<ResourceId> returned_ids;
   for (unsigned i = 0; i < 3; i++)
     returned_ids.insert(returned_to_child[i].id);
   EXPECT_EQ(expected_ids, returned_ids);
   EXPECT_FALSE(returned_to_child[0].lost);
   EXPECT_FALSE(returned_to_child[1].lost);
@@ skipping 30 matching lines @@
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     TransferableResourceArray list;
     child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
                                                  &list);
     ASSERT_EQ(1u, list.size());
-    EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
+    EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               list[0].mailbox_holder.texture_target);
     EXPECT_TRUE(child_resource_provider->InUseByConsumer(id1));
     resource_provider_->ReceiveFromChild(child_id, list);
   }
 
   EXPECT_EQ(0u, resource_provider_->num_resources());
   ASSERT_EQ(1u, returned_to_child.size());
   EXPECT_EQ(returned_to_child[0].id, id1);
   ResourceProvider::ResourceIdMap resource_map =
@@ skipping 80 matching lines @@
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(2u, list.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
-      EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
+      EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
+      EXPECT_TRUE(list[1].mailbox_holder.sync_token.HasData());
     }
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     resource_provider_->ReceiveFromChild(child_id, list);
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
@@ skipping 11 matching lines @@
   {
     // The parent transfers the resources to the grandparent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(mapped_id1);
     resource_ids_to_transfer.push_back(mapped_id2);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
 
     ASSERT_EQ(2u, list.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
-      EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
+      EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
+      EXPECT_TRUE(list[1].mailbox_holder.sync_token.HasData());
     }
     EXPECT_TRUE(resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(resource_provider_->InUseByConsumer(id2));
 
     // Release the resource in the parent. Set no resources as being in use. The
     // resources are exported so that can't be transferred back yet.
     ResourceProvider::ResourceIdSet no_resources;
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     EXPECT_EQ(0u, returned_to_child.size());
     EXPECT_EQ(2u, resource_provider_->num_resources());
 
     // Return the resources from the grandparent to the parent. They should be
     // returned to the child then.
     EXPECT_EQ(2u, list.size());
     EXPECT_EQ(mapped_id1, list[0].id);
     EXPECT_EQ(mapped_id2, list[1].id);
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
     resource_provider_->ReceiveReturnsFromParent(returned);
 
     EXPECT_EQ(0u, resource_provider_->num_resources());
     ASSERT_EQ(2u, returned_to_child.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, returned_to_child[0].sync_point);
-      EXPECT_NE(0u, returned_to_child[1].sync_point);
+      EXPECT_TRUE(returned_to_child[0].sync_token.HasData());
+      EXPECT_TRUE(returned_to_child[1].sync_token.HasData());
     }
     EXPECT_FALSE(returned_to_child[0].lost);
     EXPECT_FALSE(returned_to_child[1].lost);
   }
 }
 
 TEST_P(ResourceProviderTest, DestroyChildWithExportedResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
@@ skipping 15 matching lines @@
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(2u, list.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
-      EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
+      EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
+      EXPECT_TRUE(list[1].mailbox_holder.sync_token.HasData());
     }
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     resource_provider_->ReceiveFromChild(child_id, list);
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
@@ skipping 11 matching lines @@
   {
     // The parent transfers the resources to the grandparent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(mapped_id1);
     resource_ids_to_transfer.push_back(mapped_id2);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
 
     ASSERT_EQ(2u, list.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
-      EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
+      EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
+      EXPECT_TRUE(list[1].mailbox_holder.sync_token.HasData());
     }
     EXPECT_TRUE(resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(resource_provider_->InUseByConsumer(id2));
 
     // Release the resource in the parent. Set no resources as being in use. The
     // resources are exported so that can't be transferred back yet.
     ResourceProvider::ResourceIdSet no_resources;
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     // Destroy the child, the resources should not be returned yet.
@@ skipping 13 matching lines @@
     TransferableResourceArray return_list;
     return_list.push_back(list[1]);
     list.pop_back();
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(return_list, &returned);
     resource_provider_->ReceiveReturnsFromParent(returned);
 
     EXPECT_EQ(1u, resource_provider_->num_resources());
     ASSERT_EQ(1u, returned_to_child.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, returned_to_child[0].sync_point);
+      EXPECT_TRUE(returned_to_child[0].sync_token.HasData());
     }
     EXPECT_FALSE(returned_to_child[0].lost);
     returned_to_child.clear();
 
     // Destroy the parent resource provider. The resource that's left should be
     // lost at this point, and returned.
     resource_provider_ = nullptr;
     ASSERT_EQ(1u, returned_to_child.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-      EXPECT_NE(0u, returned_to_child[0].sync_point);
+      EXPECT_TRUE(returned_to_child[0].sync_token.HasData());
     }
     EXPECT_TRUE(returned_to_child[0].lost);
   }
 }
 
 TEST_P(ResourceProviderTest, DeleteTransferredResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id, data, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(1u, list.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
-      EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
+      EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id));
     resource_provider_->ReceiveFromChild(child_id, list);
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
 
   // Delete textures in the child, while they are transfered.
   child_resource_provider_->DeleteResource(id);
   EXPECT_EQ(1u, child_resource_provider_->num_resources());
   {
     EXPECT_EQ(0u, returned_to_child.size());
 
     // Transfer resources back from the parent to the child. Set no resources as
     // being in use.
     ResourceProvider::ResourceIdSet no_resources;
     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 
     ASSERT_EQ(1u, returned_to_child.size());
     if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
-      EXPECT_NE(0u, returned_to_child[0].sync_point);
+      EXPECT_TRUE(returned_to_child[0].sync_token.HasData());
     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
   }
   EXPECT_EQ(0u, child_resource_provider_->num_resources());
 }
 
 TEST_P(ResourceProviderTest, UnuseTransferredResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
@@ skipping 202 matching lines @@
 
       ASSERT_EQ(1u, list.size());
       EXPECT_EQ(static_cast<unsigned>(child_filter), list[0].filter);
 
       EXPECT_CALL(*parent_context,
                   createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _))
           .WillOnce(Return(parent_texture_id));
 
       parent_resource_provider->ReceiveFromChild(child_id, list);
       {
-        parent_resource_provider->WaitSyncPointIfNeeded(list[0].id);
+        parent_resource_provider->WaitSyncTokenIfNeeded(list[0].id);
         ResourceProvider::ScopedReadLockGL lock(parent_resource_provider.get(),
                                                 list[0].id);
       }
       Mock::VerifyAndClearExpectations(parent_context);
 
       ResourceProvider::ResourceIdSet resource_ids_to_receive;
       resource_ids_to_receive.insert(id);
       parent_resource_provider->DeclareUsedResourcesFromChild(
           child_id, resource_ids_to_receive);
       Mock::VerifyAndClearExpectations(parent_context);
@@ skipping 63 matching lines @@
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   uint8_t data[4] = { 1, 2, 3, 4 };
   context()->texImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
-  uint32 sync_point = context()->insertSyncPoint();
+  gpu::SyncToken sync_token(context()->insertSyncPoint());
 
-  // All the logic below assumes that the sync points are all positive.
-  EXPECT_LT(0u, sync_point);
+  // All the logic below assumes that the sync token releases are all positive.
+  EXPECT_LT(0u, sync_token.release_count());
 
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   BlockingTaskRunner* main_thread_task_runner = NULL;
-  ReleaseCallbackImpl callback = base::Bind(ReleaseCallback,
-                                            &release_sync_point,
-                                            &lost_resource,
-                                            &main_thread_task_runner);
+  ReleaseCallbackImpl callback =
+      base::Bind(ReleaseCallback, &release_sync_token, &lost_resource,
+                 &main_thread_task_runner);
   ResourceId resource = resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
+      TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D),
       SingleReleaseCallbackImpl::Create(callback));
   EXPECT_EQ(1u, context()->NumTextures());
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
-    EXPECT_LE(sync_point, list[0].mailbox_holder.sync_point);
+    EXPECT_LE(sync_token.release_count(),
+              list[0].mailbox_holder.sync_token.release_count());
     EXPECT_EQ(0,
               memcmp(mailbox.name,
                      list[0].mailbox_holder.mailbox.name,
                      sizeof(mailbox.name)));
-    EXPECT_EQ(0u, release_sync_point);
+    EXPECT_FALSE(release_sync_token.HasData());
 
-    context()->waitSyncPoint(list[0].mailbox_holder.sync_point);
+    context()->waitSyncToken(list[0].mailbox_holder.sync_token.GetConstData());
     unsigned other_texture =
         context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     uint8_t test_data[4] = { 0 };
     context()->GetPixels(
         gfx::Size(1, 1), RGBA_8888, test_data);
     EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
 
     context()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D,
                                             mailbox.name);
     context()->deleteTexture(other_texture);
-    list[0].mailbox_holder.sync_point = context()->insertSyncPoint();
-    EXPECT_LT(0u, list[0].mailbox_holder.sync_point);
+    list[0].mailbox_holder.sync_token =
+        gpu::SyncToken(context()->insertSyncPoint());
 
     // Receive the resource, then delete it, expect the sync points to be
     // consistent.
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
     resource_provider_->ReceiveReturnsFromParent(returned);
     EXPECT_EQ(1u, context()->NumTextures());
-    EXPECT_EQ(0u, release_sync_point);
+    EXPECT_FALSE(release_sync_token.HasData());
 
     resource_provider_->DeleteResource(resource);
-    EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
+    EXPECT_LE(list[0].mailbox_holder.sync_token.release_count(),
+              release_sync_token.release_count());
     EXPECT_FALSE(lost_resource);
     EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
   }
 
   // We're going to do the same thing as above, but testing the case where we
   // delete the resource before we receive it back.
-  sync_point = release_sync_point;
-  EXPECT_LT(0u, sync_point);
-  release_sync_point = 0;
+  sync_token = release_sync_token;
+  EXPECT_LT(0u, sync_token.release_count());
+  release_sync_token.Clear();
   resource = resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
+      TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D),
       SingleReleaseCallbackImpl::Create(callback));
   EXPECT_EQ(1u, context()->NumTextures());
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
-    EXPECT_LE(sync_point, list[0].mailbox_holder.sync_point);
+    EXPECT_LE(sync_token.release_count(),
+              list[0].mailbox_holder.sync_token.release_count());
     EXPECT_EQ(0,
               memcmp(mailbox.name,
                      list[0].mailbox_holder.mailbox.name,
                      sizeof(mailbox.name)));
-    EXPECT_EQ(0u, release_sync_point);
+    EXPECT_FALSE(release_sync_token.HasData());
 
-    context()->waitSyncPoint(list[0].mailbox_holder.sync_point);
+    context()->waitSyncToken(list[0].mailbox_holder.sync_token.GetConstData());
     unsigned other_texture =
         context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     uint8_t test_data[4] = { 0 };
     context()->GetPixels(
         gfx::Size(1, 1), RGBA_8888, test_data);
     EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
 
     context()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D,
                                             mailbox.name);
     context()->deleteTexture(other_texture);
-    list[0].mailbox_holder.sync_point = context()->insertSyncPoint();
-    EXPECT_LT(0u, list[0].mailbox_holder.sync_point);
+    list[0].mailbox_holder.sync_token =
+        gpu::SyncToken(context()->insertSyncPoint());
+    EXPECT_LT(0u, list[0].mailbox_holder.sync_token.release_count());
 
     // Delete the resource, which shouldn't do anything.
     resource_provider_->DeleteResource(resource);
     EXPECT_EQ(1u, context()->NumTextures());
-    EXPECT_EQ(0u, release_sync_point);
+    EXPECT_FALSE(release_sync_token.HasData());
 
     // Then receive the resource which should release the mailbox, expect the
     // sync points to be consistent.
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
     resource_provider_->ReceiveReturnsFromParent(returned);
-    EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
+    EXPECT_LE(list[0].mailbox_holder.sync_token.release_count(),
+              release_sync_token.release_count());
     EXPECT_FALSE(lost_resource);
     EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
   }
 
-  context()->waitSyncPoint(release_sync_point);
+  context()->waitSyncToken(release_sync_token.GetConstData());
   texture =
       context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   context()->deleteTexture(texture);
 }
 
 TEST_P(ResourceProviderTest, LostResourceInParent) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceId resource = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
@@ skipping 118 matching lines @@
   }
 
   // The resource should be lost.
   EXPECT_TRUE(child_resource_provider_->IsLost(resource));
 
   // Lost resources stay in use in the parent forever.
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(resource));
 }
 
 TEST_P(ResourceProviderTest, LostMailboxInParent) {
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   bool release_called = false;
-  uint32 sync_point = 0;
-  ResourceId resource = CreateChildMailbox(&release_sync_point, &lost_resource,
-                                           &release_called, &sync_point);
+  gpu::SyncToken sync_token;
+  ResourceId resource = CreateChildMailbox(&release_sync_token, &lost_resource,
+                                           &release_called, &sync_token);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 27 matching lines @@
   }
 
   // Delete the resource in the child. Expect the resource to be lost if it's
   // a GL texture.
   child_resource_provider_->DeleteResource(resource);
   EXPECT_EQ(lost_resource,
             GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE);
 }
 
 TEST_P(ResourceProviderTest, LostMailboxInGrandParent) {
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   bool release_called = false;
-  uint32 sync_point = 0;
-  ResourceId resource = CreateChildMailbox(&release_sync_point, &lost_resource,
-                                           &release_called, &sync_point);
+  gpu::SyncToken sync_token;
+  ResourceId resource = CreateChildMailbox(&release_sync_token, &lost_resource,
+                                           &release_called, &sync_token);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 44 matching lines @@
     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
     returned_to_child.clear();
   }
 
   // Delete the resource in the child. Expect the resource to be lost.
   child_resource_provider_->DeleteResource(resource);
   EXPECT_TRUE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, Shutdown) {
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   bool release_called = false;
-  uint32 sync_point = 0;
-  CreateChildMailbox(
-      &release_sync_point, &lost_resource, &release_called, &sync_point);
+  gpu::SyncToken sync_token;
+  CreateChildMailbox(&release_sync_token, &lost_resource, &release_called,
+                     &sync_token);
 
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   EXPECT_FALSE(lost_resource);
 
   child_resource_provider_ = nullptr;
 
   if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
-    EXPECT_LE(sync_point, release_sync_point);
+    EXPECT_LE(sync_token.release_count(), release_sync_token.release_count());
   }
   EXPECT_TRUE(release_called);
   EXPECT_FALSE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   bool release_called = false;
-  uint32 sync_point = 0;
-  ResourceId resource = CreateChildMailbox(&release_sync_point, &lost_resource,
-                                           &release_called, &sync_point);
+  gpu::SyncToken sync_token;
+  ResourceId resource = CreateChildMailbox(&release_sync_token, &lost_resource,
+                                           &release_called, &sync_token);
 
   // Transfer the resource, so we can't release it properly on shutdown.
   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
   resource_ids_to_transfer.push_back(resource);
   TransferableResourceArray list;
   child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                 &list);
 
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   EXPECT_FALSE(lost_resource);
 
   child_resource_provider_ = nullptr;
 
   // Since the resource is in the parent, the child considers it lost.
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   EXPECT_TRUE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, LostContext) {
   // TextureMailbox callbacks only exist for GL textures for now.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
-  uint32 sync_point = context()->insertSyncPoint();
+  gpu::SyncToken sync_token(context()->insertSyncPoint());
 
-  EXPECT_LT(0u, sync_point);
+  EXPECT_TRUE(sync_token.HasData());
 
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   BlockingTaskRunner* main_thread_task_runner = NULL;
   scoped_ptr<SingleReleaseCallbackImpl> callback =
-      SingleReleaseCallbackImpl::Create(base::Bind(ReleaseCallback,
-                                                   &release_sync_point,
-                                                   &lost_resource,
-                                                   &main_thread_task_runner));
+      SingleReleaseCallbackImpl::Create(
+          base::Bind(ReleaseCallback, &release_sync_token, &lost_resource,
+                     &main_thread_task_runner));
   resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point), callback.Pass());
+      TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D), callback.Pass());
 
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   EXPECT_FALSE(lost_resource);
   EXPECT_EQ(NULL, main_thread_task_runner);
 
   resource_provider_->DidLoseOutputSurface();
   resource_provider_ = nullptr;
 
-  EXPECT_LE(sync_point, release_sync_point);
+  EXPECT_LE(sync_token.release_count(), release_sync_token.release_count());
   EXPECT_TRUE(lost_resource);
   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
 }
 
 TEST_P(ResourceProviderTest, ScopedSampler) {
   // Sampling is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
@@ skipping 228 matching lines @@
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::CreateSoftware(make_scoped_ptr(
           new SoftwareOutputDevice)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,
       use_image_texture_targets_));
 
-  uint32 release_sync_point = 0;
+  gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   BlockingTaskRunner* main_thread_task_runner = NULL;
   scoped_ptr<SingleReleaseCallbackImpl> callback =
-      SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
-                                                   &release_sync_point,
-                                                   &lost_resource,
-                                                   &main_thread_task_runner));
+      SingleReleaseCallbackImpl::Create(
+          base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource,
+                     &main_thread_task_runner));
   TextureMailbox mailbox(shared_bitmap.get(), size);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   {
     ResourceProvider::ScopedReadLockSoftware lock(resource_provider.get(), id);
     const SkBitmap* sk_bitmap = lock.sk_bitmap();
     EXPECT_EQ(sk_bitmap->width(), size.width());
     EXPECT_EQ(sk_bitmap->height(), size.height());
     EXPECT_EQ(*sk_bitmap->getAddr32(16, 16), kBadBeef);
   }
 
   resource_provider->DeleteResource(id);
-  EXPECT_EQ(0u, release_sync_point);
+  EXPECT_FALSE(release_sync_token.HasData());
   EXPECT_FALSE(lost_resource);
   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
 }
 
 class ResourceProviderTestTextureMailboxGLFilters
     : public ResourceProviderTest {
  public:
   static void RunTest(TestSharedBitmapManager* shared_bitmap_manager,
                       TestGpuMemoryBufferManager* gpu_memory_buffer_manager,
                       BlockingTaskRunner* main_thread_task_runner,
                       bool mailbox_nearest_neighbor,
                       GLenum sampler_filter) {
     scoped_ptr<TextureStateTrackingContext> context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* context = context_owned.get();
 
     FakeOutputSurfaceClient output_surface_client;
     scoped_ptr<OutputSurface> output_surface(
         FakeOutputSurface::Create3d(context_owned.Pass()));
     CHECK(output_surface->BindToClient(&output_surface_client));
 
     scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
         output_surface.get(), shared_bitmap_manager, gpu_memory_buffer_manager,
         main_thread_task_runner, 0, 1, use_image_texture_targets_));
 
     unsigned texture_id = 1;
-    uint32 sync_point = 30;
+    gpu::SyncToken sync_token(30);
     unsigned target = GL_TEXTURE_2D;
 
     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
     gpu::Mailbox gpu_mailbox;
     memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
-    uint32 release_sync_point = 0;
+    gpu::SyncToken release_sync_token;
     bool lost_resource = false;
     BlockingTaskRunner* mailbox_task_runner = NULL;
     scoped_ptr<SingleReleaseCallbackImpl> callback =
-        SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
-                                                     &release_sync_point,
-                                                     &lost_resource,
-                                                     &mailbox_task_runner));
+        SingleReleaseCallbackImpl::Create(
+            base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource,
+                       &mailbox_task_runner));
 
-    TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+    TextureMailbox mailbox(gpu_mailbox, sync_token, target);
     mailbox.set_nearest_neighbor(mailbox_nearest_neighbor);
 
     ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
         mailbox, callback.Pass());
     EXPECT_NE(0u, id);
 
     Mock::VerifyAndClearExpectations(context);
 
     {
-      // Mailbox sync point WaitSyncPoint before using the texture.
-      EXPECT_CALL(*context, waitSyncPoint(sync_point));
-      resource_provider->WaitSyncPointIfNeeded(id);
+      // Mailbox sync point WaitSyncToken before using the texture.
+      EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
+      resource_provider->WaitSyncTokenIfNeeded(id);
       Mock::VerifyAndClearExpectations(context);
 
       EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _))
           .WillOnce(Return(texture_id));
       EXPECT_CALL(*context, bindTexture(target, texture_id));
 
       EXPECT_CALL(*context, insertSyncPoint()).Times(0);
       EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
       // The sampler will reset these if |mailbox_nearest_neighbor| does not
       // match |sampler_filter|.
       if (mailbox_nearest_neighbor != (sampler_filter == GL_NEAREST)) {
         EXPECT_CALL(*context, texParameteri(
             GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, sampler_filter));
         EXPECT_CALL(*context, texParameteri(
             GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, sampler_filter));
       }
 
       ResourceProvider::ScopedSamplerGL lock(
           resource_provider.get(), id, sampler_filter);
       Mock::VerifyAndClearExpectations(context);
 
       // When done with it, a sync point should be inserted, but no produce is
       // necessary.
       EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
       EXPECT_CALL(*context, insertSyncPoint());
       EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
-      EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+      EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
       EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
     }
 
     resource_provider->DeleteResource(id);
-    EXPECT_EQ(0u, release_sync_point);
+    EXPECT_FALSE(release_sync_token.HasData());
     EXPECT_FALSE(lost_resource);
     EXPECT_EQ(main_thread_task_runner, mailbox_task_runner);
   }
 };
 
 TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_LinearToLinear) {
   // Mailboxing is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
@@ skipping 56 matching lines @@
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(context_owned.Pass()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), NULL, 0, 1,
       use_image_texture_targets_));
 
-  uint32 sync_point = 30;
+  gpu::SyncToken sync_token(30);
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+  EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 
-  TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+  TextureMailbox mailbox(gpu_mailbox, sync_token, target);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
-    // Mailbox sync point WaitSyncPoint before using the texture.
-    EXPECT_CALL(*context, waitSyncPoint(sync_point));
-    resource_provider->WaitSyncPointIfNeeded(id);
+    // Mailbox sync point WaitSyncToken before using the texture.
+    EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
+    resource_provider->WaitSyncTokenIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
 
     unsigned texture_id = 1;
 
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _))
         .WillOnce(Return(texture_id));
 
     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
     ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
     Mock::VerifyAndClearExpectations(context);
 
     // When done with it, a sync point should be inserted, but no produce is
     // necessary.
     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
     EXPECT_CALL(*context, insertSyncPoint());
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
   }
 }
 
 TEST_P(ResourceProviderTest,
-       TextureMailbox_WaitSyncPointIfNeeded_WithSyncPoint) {
+       TextureMailbox_WaitSyncTokenIfNeeded_WithSyncToken) {
   // Mailboxing is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(context_owned.Pass()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), NULL, 0, 1,
       use_image_texture_targets_));
 
-  uint32 sync_point = 30;
+  gpu::SyncToken sync_token(30);
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+  EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 
-  TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+  TextureMailbox mailbox(gpu_mailbox, sync_token, target);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
-    // First call to WaitSyncPointIfNeeded should call waitSyncPoint.
-    EXPECT_CALL(*context, waitSyncPoint(sync_point));
-    resource_provider->WaitSyncPointIfNeeded(id);
+    // First call to WaitSyncTokenIfNeeded should call waitSyncToken.
+    EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
+    resource_provider->WaitSyncTokenIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
 
-    // Subsequent calls to WaitSyncPointIfNeeded shouldn't call waitSyncPoint.
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
-    resource_provider->WaitSyncPointIfNeeded(id);
+    // Subsequent calls to WaitSyncTokenIfNeeded shouldn't call waitSyncToken.
+    EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
+    resource_provider->WaitSyncTokenIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
   }
 }
 
-TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncPointIfNeeded_NoSyncPoint) {
+TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncTokenIfNeeded_NoSyncToken) {
   // Mailboxing is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(context_owned.Pass()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), NULL, 0, 1,
       use_image_texture_targets_));
 
-  uint32 sync_point = 0;
+  gpu::SyncToken sync_token;
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+  EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 
-  TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+  TextureMailbox mailbox(gpu_mailbox, sync_token, target);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
-    // WaitSyncPointIfNeeded with sync_point == 0 shouldn't call waitSyncPoint.
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
-    resource_provider->WaitSyncPointIfNeeded(id);
+    // WaitSyncTokenIfNeeded with empty sync_token shouldn't call waitSyncToken.
+    EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
+    resource_provider->WaitSyncTokenIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
   }
 }
 
 class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD0(NextTextureId, GLuint());
   MOCK_METHOD1(RetireTextureId, void(GLuint id));
   MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
   MOCK_METHOD5(texStorage2DEXT,
@@ skipping 441 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc