diff --git a/android_webview/browser/deferred_gpu_command_service.cc b/android_webview/browser/deferred_gpu_command_service.cc
index 6f0a146..648c3c3 100644
--- a/android_webview/browser/deferred_gpu_command_service.cc
+++ b/android_webview/browser/deferred_gpu_command_service.cc
@@ -71,8 +71,7 @@
 DeferredGpuCommandService::DeferredGpuCommandService()
     : gpu::InProcessCommandBuffer::Service(
           content::GetGpuPreferencesFromCommandLine()),
-      sync_point_manager_(new gpu::SyncPointManager(true)) {
-}
+      sync_point_manager_(new gpu::SyncPointManager()) {}
 
 DeferredGpuCommandService::~DeferredGpuCommandService() {
   base::AutoLock lock(tasks_lock_);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index aad78dd..15aa3b1b 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -31,6 +31,7 @@
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
@@ -594,7 +595,7 @@
   void SetShaderCacheCallback(const ShaderCacheCallback& callback) override;
   void SetFenceSyncReleaseCallback(
       const FenceSyncReleaseCallback& callback) override;
-  void SetWaitFenceSyncCallback(const WaitFenceSyncCallback& callback) override;
+  void SetWaitSyncTokenCallback(const WaitSyncTokenCallback& callback) override;
 
   void SetDescheduleUntilFinishedCallback(
       const NoParamCallback& callback) override;
@@ -2302,7 +2303,7 @@
   std::unique_ptr<ImageManager> image_manager_;
 
   FenceSyncReleaseCallback fence_sync_release_callback_;
-  WaitFenceSyncCallback wait_fence_sync_callback_;
+  WaitSyncTokenCallback wait_sync_token_callback_;
   NoParamCallback deschedule_until_finished_callback_;
   NoParamCallback reschedule_after_finished_callback_;
 
@@ -4660,9 +4661,9 @@
   fence_sync_release_callback_ = callback;
 }
 
-void GLES2DecoderImpl::SetWaitFenceSyncCallback(
-    const WaitFenceSyncCallback& callback) {
-  wait_fence_sync_callback_ = callback;
+void GLES2DecoderImpl::SetWaitSyncTokenCallback(
+    const WaitSyncTokenCallback& callback) {
+  wait_sync_token_callback_ = callback;
 }
 
 void GLES2DecoderImpl::SetDescheduleUntilFinishedCallback(
@@ -15822,12 +15823,14 @@
   const CommandBufferId command_buffer_id =
       CommandBufferId::FromUnsafeValue(c.command_buffer_id());
   const uint64_t release = c.release_count();
-  if (wait_fence_sync_callback_.is_null())
+  if (wait_sync_token_callback_.is_null())
     return error::kNoError;
 
-  return wait_fence_sync_callback_.Run(namespace_id, command_buffer_id, release)
-             ? error::kNoError
-             : error::kDeferCommandUntilLater;
+  gpu::SyncToken sync_token;
+  sync_token.Set(namespace_id, 0, command_buffer_id, release);
+  return wait_sync_token_callback_.Run(sync_token)
+             ? error::kDeferCommandUntilLater
+             : error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDiscardBackbufferCHROMIUM(
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index c53b522..d7d8a23 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -36,6 +36,7 @@
 namespace gpu {
 
 struct Mailbox;
+struct SyncToken;
 
 namespace gles2 {
 
@@ -85,10 +86,7 @@
  public:
   typedef error::Error Error;
   typedef base::Callback<void(uint64_t release)> FenceSyncReleaseCallback;
-  typedef base::Callback<bool(gpu::CommandBufferNamespace namespace_id,
-                              gpu::CommandBufferId command_buffer_id,
-                              uint64_t release)>
-      WaitFenceSyncCallback;
+  typedef base::Callback<bool(const gpu::SyncToken&)> WaitSyncTokenCallback;
   typedef base::Callback<void(void)> NoParamCallback;
 
   // The default stencil mask, which has all bits set.  This really should be a
@@ -281,11 +279,12 @@
   virtual void SetShaderCacheCallback(const ShaderCacheCallback& callback) = 0;
 
   // Sets the callback for fence sync release and wait calls. The wait call
-  // returns true if the channel is still scheduled.
+  // returns false if the wait was a nop or invalid and the command buffer is
+  // still scheduled.
   virtual void SetFenceSyncReleaseCallback(
       const FenceSyncReleaseCallback& callback) = 0;
-  virtual void SetWaitFenceSyncCallback(
-      const WaitFenceSyncCallback& callback) = 0;
+  virtual void SetWaitSyncTokenCallback(
+      const WaitSyncTokenCallback& callback) = 0;
 
   // Sets the callback for the DescheduleUntilFinished and
   // RescheduleAfterFinished calls.
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
index 206f6d3..64ca1a8 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
@@ -149,8 +149,8 @@
                void(const ShaderCacheCallback& callback));
   MOCK_METHOD1(SetFenceSyncReleaseCallback,
                void(const FenceSyncReleaseCallback& callback));
-  MOCK_METHOD1(SetWaitFenceSyncCallback,
-               void(const WaitFenceSyncCallback& callback));
+  MOCK_METHOD1(SetWaitSyncTokenCallback,
+               void(const WaitSyncTokenCallback& callback));
   MOCK_METHOD1(SetDescheduleUntilFinishedCallback,
                void(const NoParamCallback& callback));
   MOCK_METHOD1(SetRescheduleAfterFinishedCallback,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc
index 178f369..86f13e5 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc
@@ -425,9 +425,9 @@
   fence_sync_release_callback_ = callback;
 }
 
-void GLES2DecoderPassthroughImpl::SetWaitFenceSyncCallback(
-    const WaitFenceSyncCallback& callback) {
-  wait_fence_sync_callback_ = callback;
+void GLES2DecoderPassthroughImpl::SetWaitSyncTokenCallback(
+    const WaitSyncTokenCallback& callback) {
+  wait_sync_token_callback_ = callback;
 }
 
 void GLES2DecoderPassthroughImpl::SetDescheduleUntilFinishedCallback(
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h
index 0193b4aa..cd7ef379 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h
@@ -12,6 +12,7 @@
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/client_service_map.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ -134,7 +135,7 @@
   // returns true if the channel is still scheduled.
   void SetFenceSyncReleaseCallback(
       const FenceSyncReleaseCallback& callback) override;
-  void SetWaitFenceSyncCallback(const WaitFenceSyncCallback& callback) override;
+  void SetWaitSyncTokenCallback(const WaitSyncTokenCallback& callback) override;
   void SetDescheduleUntilFinishedCallback(
       const NoParamCallback& callback) override;
   void SetRescheduleAfterFinishedCallback(
@@ -327,7 +328,7 @@
 
   // Callbacks
   FenceSyncReleaseCallback fence_sync_release_callback_;
-  WaitFenceSyncCallback wait_fence_sync_callback_;
+  WaitSyncTokenCallback wait_sync_token_callback_;
 
   // Some objects may generate resources when they are bound even if they were
   // not generated yet: texture, buffer, renderbuffer, framebuffer, transform
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough_doers.cc b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough_doers.cc
index 8604e0e0..74c7a4a6 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough_doers.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough_doers.cc
@@ -3097,13 +3097,13 @@
     CommandBufferNamespace namespace_id,
     CommandBufferId command_buffer_id,
     GLuint64 release_count) {
-  if (wait_fence_sync_callback_.is_null()) {
+  if (wait_sync_token_callback_.is_null()) {
     return error::kNoError;
   }
-  return wait_fence_sync_callback_.Run(namespace_id, command_buffer_id,
-                                       release_count)
-             ? error::kNoError
-             : error::kDeferCommandUntilLater;
+  SyncToken sync_token(namespace_id, 0, command_buffer_id, release_count);
+  return wait_sync_token_callback_.Run(sync_token)
+             ? error::kDeferCommandUntilLater
+             : error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDrawBuffersEXT(
diff --git a/gpu/command_buffer/service/sync_point_manager.cc b/gpu/command_buffer/service/sync_point_manager.cc
index 04a92e0..85210e8 100644
--- a/gpu/command_buffer/service/sync_point_manager.cc
+++ b/gpu/command_buffer/service/sync_point_manager.cc
@@ -8,15 +8,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <climits>
-
 #include "base/bind.h"
-#include "base/containers/hash_tables.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/rand_util.h"
-#include "base/sequence_checker.h"
+#include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 
 namespace gpu {
@@ -146,12 +141,7 @@
 
 SyncPointOrderData::OrderFence::~OrderFence() {}
 
-SyncPointOrderData::SyncPointOrderData()
-    : current_order_num_(0),
-      paused_(false),
-      destroyed_(false),
-      processed_order_num_(0),
-      unprocessed_order_num_(0) {}
+SyncPointOrderData::SyncPointOrderData() {}
 
 SyncPointOrderData::~SyncPointOrderData() {}
 
@@ -164,8 +154,8 @@
   if (destroyed_)
     return false;
 
-  // Release should have a possible unprocessed order number lower
-  // than the wait order number.
+  // Release should have a possible unprocessed order number lower than the wait
+  // order number.
   if ((processed_order_num_ + 1) >= wait_order_num)
     return false;
 
@@ -175,7 +165,7 @@
 
   // So far it could be valid, but add an order fence guard to be sure it
   // gets released eventually.
-  const uint32_t expected_order_num =
+  uint32_t expected_order_num =
       std::min(unprocessed_order_num_, wait_order_num);
   order_fence_queue_.push(OrderFence(expected_order_num, fence_release,
                                      release_callback, client_state));
@@ -194,37 +184,32 @@
 
 SyncPointClientState::SyncPointClientState(
     scoped_refptr<SyncPointOrderData> order_data)
-    : order_data_(order_data), fence_sync_release_(0) {}
+    : order_data_(order_data) {}
 
-SyncPointClientState::~SyncPointClientState() {
+SyncPointClientState::~SyncPointClientState() {}
+
+bool SyncPointClientState::IsFenceSyncReleased(uint64_t release) {
+  base::AutoLock lock(fence_sync_lock_);
+  return release <= fence_sync_release_;
 }
 
-bool SyncPointClientState::WaitForRelease(CommandBufferNamespace namespace_id,
-                                          CommandBufferId client_id,
+bool SyncPointClientState::WaitForRelease(uint64_t release,
                                           uint32_t wait_order_num,
-                                          uint64_t release,
                                           const base::Closure& callback) {
   // Lock must be held the whole time while we validate otherwise it could be
   // released while we are checking.
   {
     base::AutoLock auto_lock(fence_sync_lock_);
-    if (release > fence_sync_release_) {
-      if (!order_data_->ValidateReleaseOrderNumber(this, wait_order_num,
-                                                   release, callback)) {
-        return false;
-      } else {
-        // Add the callback which will be called upon release.
-        release_callback_queue_.push(ReleaseCallback(release, callback));
-        if (!on_wait_callback_.is_null())
-          on_wait_callback_.Run(namespace_id, client_id);
-        return true;
-      }
+    if (release > fence_sync_release_ &&
+        order_data_->ValidateReleaseOrderNumber(this, wait_order_num, release,
+                                                callback)) {
+      // Add the callback which will be called upon release.
+      release_callback_queue_.push(ReleaseCallback(release, callback));
+      return true;
     }
   }
-
-  // Already released, run the callback now.
-  callback.Run();
-  return true;
+  // Already released, do not run the callback.
+  return false;
 }
 
 void SyncPointClientState::ReleaseFenceSync(uint64_t release) {
@@ -232,10 +217,11 @@
   std::vector<base::Closure> callback_list;
   {
     base::AutoLock auto_lock(fence_sync_lock_);
+
     DLOG_IF(ERROR, release <= fence_sync_release_)
         << "Client submitted fence releases out of order.";
-
     fence_sync_release_ = release;
+
     while (!release_callback_queue_.empty() &&
            release_callback_queue_.top().release_count <= release) {
       callback_list.push_back(release_callback_queue_.top().callback_closure);
@@ -286,166 +272,149 @@
   }
 }
 
-void SyncPointClientState::SetOnWaitCallback(const OnWaitCallback& callback) {
-  on_wait_callback_ = callback;
+SyncPointClient::SyncPointClient(SyncPointManager* sync_point_manager,
+                                 scoped_refptr<SyncPointOrderData> order_data,
+                                 CommandBufferNamespace namespace_id,
+                                 CommandBufferId command_buffer_id)
+    : sync_point_manager_(sync_point_manager),
+      order_data_(order_data),
+      client_state_(new SyncPointClientState(order_data)),
+      namespace_id_(namespace_id),
+      command_buffer_id_(command_buffer_id) {
+  sync_point_manager_->RegisterSyncPointClient(client_state_, namespace_id,
+                                               command_buffer_id);
 }
 
 SyncPointClient::~SyncPointClient() {
-  if (namespace_id_ != gpu::CommandBufferNamespace::INVALID) {
-    // Release all fences on destruction.
-    client_state_->ReleaseFenceSync(UINT64_MAX);
-
-    sync_point_manager_->DestroySyncPointClient(namespace_id_, client_id_);
-  }
+  // Release all fences on destruction.
+  client_state_->ReleaseFenceSync(UINT64_MAX);
+  sync_point_manager_->DeregisterSyncPointClient(namespace_id_,
+                                                 command_buffer_id_);
 }
 
-bool SyncPointClient::Wait(SyncPointClientState* release_state,
-                           uint64_t release_count,
-                           const base::Closure& wait_complete_callback) {
+bool SyncPointClient::Wait(const SyncToken& sync_token,
+                           const base::Closure& callback) {
   // Validate that this Wait call is between BeginProcessingOrderNumber() and
   // FinishProcessingOrderNumber(), or else we may deadlock.
-  DCHECK(client_state_->order_data()->IsProcessingOrderNumber());
-
-  const uint32_t wait_order_number =
-      client_state_->order_data()->current_order_num();
-
-  // If waiting on self or wait was invalid, call the callback and return false.
-  if (client_state_ == release_state ||
-      !release_state->WaitForRelease(namespace_id_, client_id_,
-                                     wait_order_number, release_count,
-                                     wait_complete_callback)) {
-    wait_complete_callback.Run();
+  DCHECK(order_data_->IsProcessingOrderNumber());
+  if (sync_token.namespace_id() == namespace_id_ &&
+      sync_token.command_buffer_id() == command_buffer_id_) {
     return false;
   }
-  return true;
+  uint32_t wait_order_number = order_data_->current_order_num();
+  return sync_point_manager_->Wait(sync_token, wait_order_number, callback);
 }
 
 bool SyncPointClient::WaitNonThreadSafe(
-    SyncPointClientState* release_state,
-    uint64_t release_count,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const base::Closure& wait_complete_callback) {
-  return Wait(release_state, release_count,
-              base::Bind(&RunOnThread, runner, wait_complete_callback));
-}
-
-bool SyncPointClient::WaitOutOfOrder(
-    SyncPointClientState* release_state,
-    uint64_t release_count,
-    const base::Closure& wait_complete_callback) {
-  // Validate that this Wait call is not between BeginProcessingOrderNumber()
-  // and FinishProcessingOrderNumber(), or else we may deadlock.
-  DCHECK(!client_state_ ||
-         !client_state_->order_data()->IsProcessingOrderNumber());
-
-  // No order number associated with the current execution context, using
-  // UINT32_MAX will just assume the release is in the SyncPointClientState's
-  // order numbers to be executed.
-  if (!release_state->WaitForRelease(namespace_id_, client_id_, UINT32_MAX,
-                                     release_count, wait_complete_callback)) {
-    wait_complete_callback.Run();
-    return false;
-  }
-  return true;
-}
-
-bool SyncPointClient::WaitOutOfOrderNonThreadSafe(
-    SyncPointClientState* release_state,
-    uint64_t release_count,
-    scoped_refptr<base::SingleThreadTaskRunner> runner,
-    const base::Closure& wait_complete_callback) {
-  return WaitOutOfOrder(
-      release_state, release_count,
-      base::Bind(&RunOnThread, runner, wait_complete_callback));
+    const SyncToken& sync_token,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const base::Closure& callback) {
+  return Wait(sync_token, base::Bind(&RunOnThread, task_runner, callback));
 }
 
 void SyncPointClient::ReleaseFenceSync(uint64_t release) {
   // Validate that this Release call is between BeginProcessingOrderNumber() and
   // FinishProcessingOrderNumber(), or else we may deadlock.
-  DCHECK(client_state_->order_data()->IsProcessingOrderNumber());
+  DCHECK(order_data_->IsProcessingOrderNumber());
   client_state_->ReleaseFenceSync(release);
 }
 
-void SyncPointClient::SetOnWaitCallback(const OnWaitCallback& callback) {
-  client_state_->SetOnWaitCallback(callback);
-}
-
-SyncPointClient::SyncPointClient()
-    : sync_point_manager_(nullptr),
-      namespace_id_(gpu::CommandBufferNamespace::INVALID),
-      client_id_() {}
-
-SyncPointClient::SyncPointClient(SyncPointManager* sync_point_manager,
-                                 scoped_refptr<SyncPointOrderData> order_data,
-                                 CommandBufferNamespace namespace_id,
-                                 CommandBufferId client_id)
-    : sync_point_manager_(sync_point_manager),
-      client_state_(new SyncPointClientState(order_data)),
-      namespace_id_(namespace_id),
-      client_id_(client_id) {}
-
-SyncPointManager::SyncPointManager(bool allow_threaded_wait) {
+SyncPointManager::SyncPointManager() {
   global_order_num_.GetNext();
 }
 
 SyncPointManager::~SyncPointManager() {
-  for (const ClientMap& client_map : client_maps_) {
-    DCHECK(client_map.empty());
-  }
+  for (const ClientStateMap& client_state_map : client_state_maps_)
+    DCHECK(client_state_map.empty());
 }
 
-std::unique_ptr<SyncPointClient> SyncPointManager::CreateSyncPointClient(
-    scoped_refptr<SyncPointOrderData> order_data,
+bool SyncPointManager::IsSyncTokenReleased(const SyncToken& sync_token) {
+  scoped_refptr<SyncPointClientState> release_state = GetSyncPointClientState(
+      sync_token.namespace_id(), sync_token.command_buffer_id());
+  if (release_state)
+    return release_state->IsFenceSyncReleased(sync_token.release_count());
+  return true;
+}
+
+bool SyncPointManager::Wait(const SyncToken& sync_token,
+                            uint32_t wait_order_num,
+                            const base::Closure& callback) {
+  scoped_refptr<SyncPointClientState> release_state = GetSyncPointClientState(
+      sync_token.namespace_id(), sync_token.command_buffer_id());
+  if (release_state &&
+      release_state->WaitForRelease(sync_token.release_count(), wait_order_num,
+                                    callback)) {
+    return true;
+  }
+  // Do not run callback if wait is invalid.
+  return false;
+}
+
+bool SyncPointManager::WaitNonThreadSafe(
+    const SyncToken& sync_token,
+    uint32_t wait_order_num,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const base::Closure& callback) {
+  return Wait(sync_token, wait_order_num,
+              base::Bind(&RunOnThread, task_runner, callback));
+}
+
+bool SyncPointManager::WaitOutOfOrder(const SyncToken& trusted_sync_token,
+                                      const base::Closure& callback) {
+  // No order number associated with the current execution context, using
+  // UINT32_MAX will just assume the release is in the SyncPointClientState's
+  // order numbers to be executed.
+  return Wait(trusted_sync_token, UINT32_MAX, callback);
+}
+
+bool SyncPointManager::WaitOutOfOrderNonThreadSafe(
+    const SyncToken& trusted_sync_token,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const base::Closure& callback) {
+  return WaitOutOfOrder(trusted_sync_token,
+                        base::Bind(&RunOnThread, task_runner, callback));
+}
+
+void SyncPointManager::RegisterSyncPointClient(
+    scoped_refptr<SyncPointClientState> client_state,
     CommandBufferNamespace namespace_id,
-    CommandBufferId client_id) {
+    CommandBufferId command_buffer_id) {
   DCHECK_GE(namespace_id, 0);
-  DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
-  base::AutoLock auto_lock(client_maps_lock_);
+  DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_state_maps_));
 
-  ClientMap& client_map = client_maps_[namespace_id];
-  std::pair<ClientMap::iterator, bool> result = client_map.insert(
-      std::make_pair(client_id, new SyncPointClient(this, order_data,
-                                                    namespace_id, client_id)));
-  DCHECK(result.second);
-
-  return base::WrapUnique(result.first->second);
+  base::AutoLock auto_lock(client_state_maps_lock_);
+  DCHECK(!client_state_maps_[namespace_id].count(command_buffer_id));
+  client_state_maps_[namespace_id].insert(
+      std::make_pair(command_buffer_id, client_state));
 }
 
-std::unique_ptr<SyncPointClient>
-SyncPointManager::CreateSyncPointClientWaiter() {
-  return base::WrapUnique(new SyncPointClient);
-}
-
-scoped_refptr<SyncPointClientState> SyncPointManager::GetSyncPointClientState(
+void SyncPointManager::DeregisterSyncPointClient(
     CommandBufferNamespace namespace_id,
-    CommandBufferId client_id) {
-  if (namespace_id >= 0) {
-    DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
-    base::AutoLock auto_lock(client_maps_lock_);
-    ClientMap& client_map = client_maps_[namespace_id];
-    ClientMap::iterator it = client_map.find(client_id);
-    if (it != client_map.end()) {
-      return it->second->client_state();
-    }
-  }
-  return nullptr;
+    CommandBufferId command_buffer_id) {
+  DCHECK_GE(namespace_id, 0);
+  DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_state_maps_));
+
+  base::AutoLock auto_lock(client_state_maps_lock_);
+  DCHECK(client_state_maps_[namespace_id].count(command_buffer_id));
+  client_state_maps_[namespace_id].erase(command_buffer_id);
 }
 
 uint32_t SyncPointManager::GenerateOrderNumber() {
   return global_order_num_.GetNext();
 }
 
-void SyncPointManager::DestroySyncPointClient(
+scoped_refptr<SyncPointClientState> SyncPointManager::GetSyncPointClientState(
     CommandBufferNamespace namespace_id,
-    CommandBufferId client_id) {
-  DCHECK_GE(namespace_id, 0);
-  DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
-
-  base::AutoLock auto_lock(client_maps_lock_);
-  ClientMap& client_map = client_maps_[namespace_id];
-  ClientMap::iterator it = client_map.find(client_id);
-  DCHECK(it != client_map.end());
-  client_map.erase(it);
+    CommandBufferId command_buffer_id) {
+  if (namespace_id >= 0) {
+    DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_state_maps_));
+    base::AutoLock auto_lock(client_state_maps_lock_);
+    ClientStateMap& client_state_map = client_state_maps_[namespace_id];
+    auto it = client_state_map.find(command_buffer_id);
+    if (it != client_state_map.end())
+      return it->second;
+  }
+  return nullptr;
 }
 
 }  // namespace gpu
diff --git a/gpu/command_buffer/service/sync_point_manager.h b/gpu/command_buffer/service/sync_point_manager.h
index 7a3695c..a34a17c 100644
--- a/gpu/command_buffer/service/sync_point_manager.h
+++ b/gpu/command_buffer/service/sync_point_manager.h
@@ -23,6 +23,7 @@
 #include "base/threading/thread_checker.h"
 #include "gpu/command_buffer/common/command_buffer_id.h"
 #include "gpu/command_buffer/common/constants.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/gpu_export.h"
 
 namespace base {
@@ -66,9 +67,14 @@
     return !paused_ && current_order_num_ > processed_order_num();
   }
 
+  bool ValidateReleaseOrderNumber(
+      scoped_refptr<SyncPointClientState> client_state,
+      uint32_t wait_order_num,
+      uint64_t fence_release,
+      const base::Closure& release_callback);
+
  private:
   friend class base::RefCountedThreadSafe<SyncPointOrderData>;
-  friend class SyncPointClientState;
 
   struct OrderFence {
     uint32_t order_num;
@@ -84,32 +90,26 @@
     ~OrderFence();
 
     bool operator>(const OrderFence& rhs) const {
-      return (order_num > rhs.order_num) ||
-             ((order_num == rhs.order_num) &&
-              (fence_release > rhs.fence_release));
+      return std::tie(order_num, fence_release) >
+             std::tie(rhs.order_num, rhs.fence_release);
     }
   };
   typedef std::priority_queue<OrderFence,
                               std::vector<OrderFence>,
-                              std::greater<OrderFence>> OrderFenceQueue;
+                              std::greater<OrderFence>>
+      OrderFenceQueue;
 
   SyncPointOrderData();
   ~SyncPointOrderData();
 
-  bool ValidateReleaseOrderNumber(
-      scoped_refptr<SyncPointClientState> client_state,
-      uint32_t wait_order_num,
-      uint64_t fence_release,
-      const base::Closure& release_callback);
-
   // Non thread-safe functions need to be called from a single thread.
   base::ThreadChecker processing_thread_checker_;
 
   // Current IPC order number being processed (only used on processing thread).
-  uint32_t current_order_num_;
+  uint32_t current_order_num_ = 0;
 
   // Whether or not the current order number is being processed or paused.
-  bool paused_;
+  bool paused_ = false;
 
   // This lock protects destroyed_, processed_order_num_,
   // unprocessed_order_num_, and order_fence_queue_. All order numbers (n) in
@@ -117,13 +117,13 @@
   //   processed_order_num_ < n <= unprocessed_order_num_.
   mutable base::Lock lock_;
 
-  bool destroyed_;
+  bool destroyed_ = false;
 
   // Last finished IPC order number.
-  uint32_t processed_order_num_;
+  uint32_t processed_order_num_ = 0;
 
   // Unprocessed order number expected to be processed under normal execution.
-  uint32_t unprocessed_order_num_;
+  uint32_t unprocessed_order_num_ = 0;
 
   // In situations where we are waiting on fence syncs that do not exist, we
   // validate by making sure the order number does not pass the order number
@@ -137,24 +137,30 @@
   DISALLOW_COPY_AND_ASSIGN(SyncPointOrderData);
 };
 
+// Internal state for sync point clients.
 class GPU_EXPORT SyncPointClientState
     : public base::RefCountedThreadSafe<SyncPointClientState> {
  public:
-  scoped_refptr<SyncPointOrderData> order_data() { return order_data_; }
+  explicit SyncPointClientState(scoped_refptr<SyncPointOrderData> order_data);
 
-  bool IsFenceSyncReleased(uint64_t release) {
-    return release <= fence_sync_release();
-  }
+  bool IsFenceSyncReleased(uint64_t release);
 
-  uint64_t fence_sync_release() {
-    base::AutoLock auto_lock(fence_sync_lock_);
-    return fence_sync_release_;
-  }
+  // Queues the callback to be called if the release is valid. If the release
+  // is invalid this function will return False and the callback will never
+  // be called.
+  bool WaitForRelease(uint64_t release,
+                      uint32_t wait_order_num,
+                      const base::Closure& callback);
+
+  // Releases a fence sync and all fence syncs below.
+  void ReleaseFenceSync(uint64_t release);
+
+  // Does not release the fence sync, but releases callbacks waiting on that
+  // fence sync.
+  void EnsureWaitReleased(uint64_t release, const base::Closure& callback);
 
  private:
   friend class base::RefCountedThreadSafe<SyncPointClientState>;
-  friend class SyncPointClient;
-  friend class SyncPointOrderData;
 
   struct ReleaseCallback {
     uint64_t release_count;
@@ -173,29 +179,8 @@
                               std::greater<ReleaseCallback>>
       ReleaseCallbackQueue;
 
-  SyncPointClientState(scoped_refptr<SyncPointOrderData> order_data);
   ~SyncPointClientState();
 
-  // Queues the callback to be called if the release is valid. If the release
-  // is invalid this function will return False and the callback will never
-  // be called.
-  bool WaitForRelease(CommandBufferNamespace namespace_id,
-                      CommandBufferId client_id,
-                      uint32_t wait_order_num,
-                      uint64_t release,
-                      const base::Closure& callback);
-
-  // Releases a fence sync and all fence syncs below.
-  void ReleaseFenceSync(uint64_t release);
-
-  // Does not release the fence sync, but releases callbacks waiting on that
-  // fence sync.
-  void EnsureWaitReleased(uint64_t release, const base::Closure& callback);
-
-  typedef base::Callback<void(CommandBufferNamespace, CommandBufferId)>
-      OnWaitCallback;
-  void SetOnWaitCallback(const OnWaitCallback& callback);
-
   // Global order data where releases will originate from.
   scoped_refptr<SyncPointOrderData> order_data_;
 
@@ -203,87 +188,47 @@
   base::Lock fence_sync_lock_;
 
   // Current fence sync release that has been signaled.
-  uint64_t fence_sync_release_;
+  uint64_t fence_sync_release_ = 0;
 
   // In well defined fence sync operations, fence syncs are released in order
   // so simply having a priority queue for callbacks is enough.
   ReleaseCallbackQueue release_callback_queue_;
 
-  // Called when a release callback is queued.
-  OnWaitCallback on_wait_callback_;
-
   DISALLOW_COPY_AND_ASSIGN(SyncPointClientState);
 };
 
 class GPU_EXPORT SyncPointClient {
  public:
-  ~SyncPointClient();
-
-  scoped_refptr<SyncPointClientState> client_state() { return client_state_; }
-
-  // Wait for a release count to be reached on a SyncPointClientState. If this
-  // function returns false, that means the wait was invalid. Otherwise if it
-  // returns True it means the release was valid. In the case where the release
-  // is valid but has happened already, it will still return true. In all cases
-  // wait_complete_callback will be called eventually. The callback function
-  // may be called on another thread so it should be thread-safe. For
-  // convenience, another non-threadsafe version is defined below where you
-  // can supply a task runner.
-  bool Wait(SyncPointClientState* release_state,
-            uint64_t release_count,
-            const base::Closure& wait_complete_callback);
-
-  bool WaitNonThreadSafe(SyncPointClientState* release_state,
-                         uint64_t release_count,
-                         scoped_refptr<base::SingleThreadTaskRunner> runner,
-                         const base::Closure& wait_complete_callback);
-
-  // Unordered waits are waits which do not occur within the global order number
-  // processing order (IE. Not between the corresponding
-  // SyncPointOrderData::BeginProcessingOrderNumber() and
-  // SyncPointOrderData::FinishProcessingOrderNumber() calls). Because fence
-  // sync releases must occur within a corresponding order number, these waits
-  // cannot deadlock because they can never depend on any fence sync releases.
-  // This is useful for IPC messages that may be processed out of order with
-  // respect to regular command buffer processing.
-  bool WaitOutOfOrder(SyncPointClientState* release_state,
-                      uint64_t release_count,
-                      const base::Closure& wait_complete_callback);
-
-  bool WaitOutOfOrderNonThreadSafe(
-      SyncPointClientState* release_state,
-      uint64_t release_count,
-      scoped_refptr<base::SingleThreadTaskRunner> runner,
-      const base::Closure& wait_complete_callback);
-
-  void ReleaseFenceSync(uint64_t release);
-
-  // This callback is called with the namespace and id of the waiting client
-  // when a release callback is queued. The callback is called on the thread
-  // where the Wait... happens and synchronization is the responsibility of the
-  // caller.
-  typedef base::Callback<void(CommandBufferNamespace, CommandBufferId)>
-      OnWaitCallback;
-  void SetOnWaitCallback(const OnWaitCallback& callback);
-
- private:
-  friend class SyncPointManager;
-
-  SyncPointClient();
   SyncPointClient(SyncPointManager* sync_point_manager,
                   scoped_refptr<SyncPointOrderData> order_data,
                   CommandBufferNamespace namespace_id,
-                  CommandBufferId client_id);
+                  CommandBufferId command_buffer_id);
+  ~SyncPointClient();
 
+  // This behaves similarly to SyncPointManager::Wait but uses the order data
+  // to guarantee no deadlocks with other clients.
+  bool Wait(const SyncToken& sync_token, const base::Closure& callback);
+
+  // Like Wait but runs the callback on the given task runner's thread.
+  bool WaitNonThreadSafe(
+      const SyncToken& sync_token,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      const base::Closure& callback);
+
+  // Release fence sync and run queued callbacks.
+  void ReleaseFenceSync(uint64_t release);
+
+ private:
   // Sync point manager is guaranteed to exist in the lifetime of the client.
-  SyncPointManager* sync_point_manager_;
+  SyncPointManager* const sync_point_manager_;
 
-  // Keep the state that is sharable across multiple threads.
+  scoped_refptr<SyncPointOrderData> order_data_;
+
   scoped_refptr<SyncPointClientState> client_state_;
 
   // Unique namespace/client id pair for this sync point client.
   const CommandBufferNamespace namespace_id_;
-  const CommandBufferId client_id_;
+  const CommandBufferId command_buffer_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointClient);
 };
@@ -292,42 +237,67 @@
 // synchronization.
 class GPU_EXPORT SyncPointManager {
  public:
-  explicit SyncPointManager(bool allow_threaded_wait);
+  SyncPointManager();
   ~SyncPointManager();
 
-  // Creates/Destroy a sync point client which message processors should hold.
-  std::unique_ptr<SyncPointClient> CreateSyncPointClient(
-      scoped_refptr<SyncPointOrderData> order_data,
-      CommandBufferNamespace namespace_id,
-      CommandBufferId client_id);
+  // Returns true if the sync token has been released or if the command buffer
+  // does not exist.
+  bool IsSyncTokenReleased(const SyncToken& sync_token);
 
-  // Creates a sync point client which cannot process order numbers but can only
-  // Wait out of order.
-  std::unique_ptr<SyncPointClient> CreateSyncPointClientWaiter();
+  // If the wait is valid (sync token hasn't been processed or command buffer
+  // does not exist), the callback is queued to run when the sync point is
+  // released. If the wait is invalid, the callback is NOT run. The callback
+  // runs on the thread the sync point is released. Clients should use
+  // SyncPointClient::Wait because that uses order data to prevent deadlocks.
+  bool Wait(const SyncToken& sync_token,
+            uint32_t wait_order_num,
+            const base::Closure& callback);
 
-  // Finds the state of an already created sync point client.
-  scoped_refptr<SyncPointClientState> GetSyncPointClientState(
-      CommandBufferNamespace namespace_id,
-      CommandBufferId client_id);
+  // Like Wait but runs the callback on the given task runner's thread.
+  bool WaitNonThreadSafe(
+      const SyncToken& sync_token,
+      uint32_t wait_order_num,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      const base::Closure& callback);
+
+  // WaitOutOfOrder allows waiting for a sync token indefinitely, so it
+  // should be used with trusted sync tokens only.
+  bool WaitOutOfOrder(const SyncToken& trusted_sync_token,
+                      const base::Closure& callback);
+
+  // Like WaitOutOfOrder but runs the callback on the given task runner's
+  // thread.
+  bool WaitOutOfOrderNonThreadSafe(
+      const SyncToken& trusted_sync_token,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      const base::Closure& callback);
+
+  // Used by SyncPointClient.
+  void RegisterSyncPointClient(scoped_refptr<SyncPointClientState> client_state,
+                               CommandBufferNamespace namespace_id,
+                               CommandBufferId command_buffer_id);
+
+  void DeregisterSyncPointClient(CommandBufferNamespace namespace_id,
+                                 CommandBufferId command_buffer_id);
+
+  // Used by SyncPointOrderData.
+  uint32_t GenerateOrderNumber();
 
  private:
-  friend class SyncPointClient;
-  friend class SyncPointOrderData;
+  using ClientStateMap = std::unordered_map<CommandBufferId,
+                                            scoped_refptr<SyncPointClientState>,
+                                            CommandBufferId::Hasher>;
 
-  using ClientMap = std::unordered_map<CommandBufferId,
-                                       SyncPointClient*,
-                                       CommandBufferId::Hasher>;
-
-  uint32_t GenerateOrderNumber();
-  void DestroySyncPointClient(CommandBufferNamespace namespace_id,
-                              CommandBufferId client_id);
+  scoped_refptr<SyncPointClientState> GetSyncPointClientState(
+      CommandBufferNamespace namespace_id,
+      CommandBufferId command_buffer_id);
 
   // Order number is global for all clients.
   base::AtomicSequenceNumber global_order_num_;
 
   // Client map holds a map of clients id to client for each namespace.
-  base::Lock client_maps_lock_;
-  ClientMap client_maps_[NUM_COMMAND_BUFFER_NAMESPACES];
+  base::Lock client_state_maps_lock_;
+  ClientStateMap client_state_maps_[NUM_COMMAND_BUFFER_NAMESPACES];
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointManager);
 };
diff --git a/gpu/command_buffer/service/sync_point_manager_unittest.cc b/gpu/command_buffer/service/sync_point_manager_unittest.cc
index a9f6c56..96b80623 100644
--- a/gpu/command_buffer/service/sync_point_manager_unittest.cc
+++ b/gpu/command_buffer/service/sync_point_manager_unittest.cc
@@ -8,6 +8,7 @@
 #include <queue>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -15,29 +16,13 @@
 
 class SyncPointManagerTest : public testing::Test {
  public:
-  SyncPointManagerTest() {}
-
+  SyncPointManagerTest() : sync_point_manager_(new SyncPointManager) {}
   ~SyncPointManagerTest() override {}
 
  protected:
-  void SetUp() override {
-    sync_point_manager_.reset(new SyncPointManager(false));
-  }
-
-  void TearDown() override { sync_point_manager_.reset(); }
-
   // Simple static function which can be used to test callbacks.
   static void SetIntegerFunction(int* test, int value) { *test = value; }
 
-  // Simple static function used for testing OnWaitCallback.
-  static void OnWait(CommandBufferNamespace* namespace_id_ptr,
-                     CommandBufferId* client_id_ptr,
-                     CommandBufferNamespace namespace_id,
-                     CommandBufferId client_id) {
-    *namespace_id_ptr = namespace_id;
-    *client_id_ptr = client_id;
-  }
-
   std::unique_ptr<SyncPointManager> sync_point_manager_;
 };
 
@@ -50,9 +35,10 @@
                   CommandBufferNamespace namespace_id,
                   CommandBufferId command_buffer_id)
       : order_data(SyncPointOrderData::Create()),
-        client(sync_point_manager->CreateSyncPointClient(order_data,
-                                                         namespace_id,
-                                                         command_buffer_id)) {}
+        client(base::MakeUnique<SyncPointClient>(sync_point_manager,
+                                                 order_data,
+                                                 namespace_id,
+                                                 command_buffer_id)) {}
 
   ~SyncPointStream() {
     order_data->Destroy();
@@ -83,7 +69,7 @@
   EXPECT_EQ(0u, order_data->processed_order_num());
   EXPECT_EQ(0u, order_data->unprocessed_order_num());
 
-  const uint32_t order_num =
+  uint32_t order_num =
       order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
   EXPECT_EQ(1u, order_num);
 
@@ -110,200 +96,195 @@
   EXPECT_FALSE(order_data->IsProcessingOrderNumber());
 }
 
-TEST_F(SyncPointManagerTest, SyncPointClientRegistration) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123);
-
-  scoped_refptr<SyncPointClientState> empty_state =
-      sync_point_manager_->GetSyncPointClientState(kNamespaceId, kBufferId);
-  EXPECT_FALSE(empty_state);
-
-  scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
-
-  std::unique_ptr<SyncPointClient> client =
-      sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
-                                                 kBufferId);
-
-  EXPECT_EQ(order_data, client->client_state()->order_data());
-  EXPECT_EQ(
-      client->client_state(),
-      sync_point_manager_->GetSyncPointClientState(kNamespaceId, kBufferId));
-}
-
 TEST_F(SyncPointManagerTest, BasicFenceSyncRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123);
 
-  scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
-  std::unique_ptr<SyncPointClient> client =
-      sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
-                                                 kBufferId);
-  scoped_refptr<SyncPointClientState> client_state = client->client_state();
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kBufferId, release_count);
 
-  EXPECT_EQ(0u, client_state->fence_sync_release());
-  EXPECT_FALSE(client_state->IsFenceSyncReleased(1));
+  // Can't wait for sync token before client is registered.
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
-  const uint32_t order_num =
-      order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
-  order_data->BeginProcessingOrderNumber(order_num);
-  client->ReleaseFenceSync(1);
-  order_data->FinishProcessingOrderNumber(order_num);
+  SyncPointStream stream(sync_point_manager_.get(), kNamespaceId, kBufferId);
 
-  EXPECT_EQ(1u, client_state->fence_sync_release());
-  EXPECT_TRUE(client_state->IsFenceSyncReleased(1));
+  stream.AllocateOrderNum(sync_point_manager_.get());
+
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
+
+  stream.order_data->BeginProcessingOrderNumber(1);
+  stream.client->ReleaseFenceSync(release_count);
+  stream.order_data->FinishProcessingOrderNumber(1);
+
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, MultipleClientsPerOrderData) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kCmdBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kCmdBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
 
-  scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
-  std::unique_ptr<SyncPointClient> client1 =
-      sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
-                                                 kBufferId1);
-  std::unique_ptr<SyncPointClient> client2 =
-      sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
-                                                 kBufferId2);
+  SyncPointStream stream1(sync_point_manager_.get(), kNamespaceId,
+                          kCmdBufferId1);
+  SyncPointStream stream2(sync_point_manager_.get(), kNamespaceId,
+                          kCmdBufferId2);
 
-  scoped_refptr<SyncPointClientState> client_state1 = client1->client_state();
-  scoped_refptr<SyncPointClientState> client_state2 = client2->client_state();
+  uint64_t release_count = 1;
+  SyncToken sync_token1(kNamespaceId, 0, kCmdBufferId1, release_count);
+  stream1.AllocateOrderNum(sync_point_manager_.get());
 
-  const uint32_t order_num =
-      order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
-  order_data->BeginProcessingOrderNumber(order_num);
-  client1->ReleaseFenceSync(1);
-  order_data->FinishProcessingOrderNumber(order_num);
+  SyncToken sync_token2(kNamespaceId, 0, kCmdBufferId2, release_count);
+  stream2.AllocateOrderNum(sync_point_manager_.get());
 
-  EXPECT_TRUE(client_state1->IsFenceSyncReleased(1));
-  EXPECT_FALSE(client_state2->IsFenceSyncReleased(1));
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token1));
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token2));
+
+  stream1.order_data->BeginProcessingOrderNumber(1);
+  stream1.client->ReleaseFenceSync(release_count);
+  stream1.order_data->FinishProcessingOrderNumber(1);
+
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token1));
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token2));
 }
 
 TEST_F(SyncPointManagerTest, BasicFenceSyncWaitRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   release_stream.AllocateOrderNum(sync_point_manager_.get());
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
   wait_stream.BeginProcessing();
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
-  ASSERT_TRUE(valid_wait);
+  EXPECT_TRUE(valid_wait);
   EXPECT_EQ(10, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
   release_stream.BeginProcessing();
-  release_stream.client->ReleaseFenceSync(1);
+  release_stream.client->ReleaseFenceSync(release_count);
   EXPECT_EQ(123, test_num);
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, WaitOnSelfFails) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
-  // Generate wait order number first.
   release_stream.AllocateOrderNum(sync_point_manager_.get());
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kWaitCmdBufferId, release_count);
+
   wait_stream.BeginProcessing();
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      wait_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
   EXPECT_FALSE(valid_wait);
-  EXPECT_EQ(123, test_num);
+  EXPECT_EQ(10, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, OutOfOrderRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   // Generate wait order number first.
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
   release_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
   wait_stream.BeginProcessing();
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
   EXPECT_FALSE(valid_wait);
-  EXPECT_EQ(123, test_num);
+  EXPECT_EQ(10, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, HigherOrderNumberRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   // Generate wait order number first.
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
   release_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
   // Order number was higher but it was actually released.
   release_stream.BeginProcessing();
-  release_stream.client->ReleaseFenceSync(1);
+  release_stream.client->ReleaseFenceSync(release_count);
   release_stream.EndProcessing();
 
+  // Release stream has already released so there's no need to wait.
   wait_stream.BeginProcessing();
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
-  EXPECT_TRUE(valid_wait);
-  EXPECT_EQ(123, test_num);
+  EXPECT_FALSE(valid_wait);
+  EXPECT_EQ(10, test_num);
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, DestroyedClientRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   release_stream.AllocateOrderNum(sync_point_manager_.get());
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
   wait_stream.BeginProcessing();
+
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
   EXPECT_TRUE(valid_wait);
   EXPECT_EQ(10, test_num);
@@ -311,18 +292,18 @@
   // Destroying the client should release the wait.
   release_stream.client.reset();
   EXPECT_EQ(123, test_num);
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, NonExistentRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   // Assign release stream order [1] and wait stream order [2].
   // This test simply tests that a wait stream of order [2] waiting on
@@ -331,31 +312,35 @@
   release_stream.AllocateOrderNum(sync_point_manager_.get());
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
   wait_stream.BeginProcessing();
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
   EXPECT_TRUE(valid_wait);
   EXPECT_EQ(10, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
   // No release but finishing the order number should automatically release.
   release_stream.BeginProcessing();
   EXPECT_EQ(10, test_num);
   release_stream.EndProcessing();
   EXPECT_EQ(123, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, NonExistentRelease2) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   // Assign Release stream order [1] and assign Wait stream orders [2, 3].
   // This test is similar to the NonExistentRelease case except
@@ -367,47 +352,52 @@
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
   // Have wait with order [3] to wait on release.
   wait_stream.BeginProcessing();
-  ASSERT_EQ(2u, wait_stream.order_data->current_order_num());
+  EXPECT_EQ(2u, wait_stream.order_data->current_order_num());
   wait_stream.EndProcessing();
   wait_stream.BeginProcessing();
-  ASSERT_EQ(3u, wait_stream.order_data->current_order_num());
+  EXPECT_EQ(3u, wait_stream.order_data->current_order_num());
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
   EXPECT_TRUE(valid_wait);
   EXPECT_EQ(10, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
   // Even though release stream order [1] did not have a release, it
   // should have changed test_num although the fence sync is still not released.
   release_stream.BeginProcessing();
-  ASSERT_EQ(1u, release_stream.order_data->current_order_num());
+  EXPECT_EQ(1u, release_stream.order_data->current_order_num());
   release_stream.EndProcessing();
-  EXPECT_FALSE(release_stream.client->client_state()->IsFenceSyncReleased(1));
   EXPECT_EQ(123, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
   // Ensure that the wait callback does not get triggered again when it is
   // actually released.
   test_num = 1;
   release_stream.AllocateOrderNum(sync_point_manager_.get());
   release_stream.BeginProcessing();
-  release_stream.client->ReleaseFenceSync(1);
+  release_stream.client->ReleaseFenceSync(release_count);
   release_stream.EndProcessing();
   EXPECT_EQ(1, test_num);
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 TEST_F(SyncPointManagerTest, NonExistentOrderNumRelease) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
+  CommandBufferNamespace kNamespaceId = gpu::CommandBufferNamespace::GPU_IO;
+  CommandBufferId kReleaseCmdBufferId = CommandBufferId::FromUnsafeValue(0x123);
+  CommandBufferId kWaitCmdBufferId = CommandBufferId::FromUnsafeValue(0x234);
 
   SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
+                                 kReleaseCmdBufferId);
   SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
+                              kWaitCmdBufferId);
 
   // Assign Release stream orders [1, 4] and assign Wait stream orders [2, 3].
   // Here we are testing that wait order [3] will wait on a fence sync
@@ -420,15 +410,18 @@
   wait_stream.AllocateOrderNum(sync_point_manager_.get());
   release_stream.AllocateOrderNum(sync_point_manager_.get());
 
+  uint64_t release_count = 1;
+  SyncToken sync_token(kNamespaceId, 0, kReleaseCmdBufferId, release_count);
+
   // Have wait with order [3] to wait on release order [1] or [2].
   wait_stream.BeginProcessing();
-  ASSERT_EQ(2u, wait_stream.order_data->current_order_num());
+  EXPECT_EQ(2u, wait_stream.order_data->current_order_num());
   wait_stream.EndProcessing();
   wait_stream.BeginProcessing();
-  ASSERT_EQ(3u, wait_stream.order_data->current_order_num());
+  EXPECT_EQ(3u, wait_stream.order_data->current_order_num());
   int test_num = 10;
-  const bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
+  bool valid_wait = wait_stream.client->Wait(
+      sync_token,
       base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
   EXPECT_TRUE(valid_wait);
   EXPECT_EQ(10, test_num);
@@ -436,74 +429,24 @@
   // Release stream should know it should release fence sync by order [3],
   // so going through order [1] should not release it yet.
   release_stream.BeginProcessing();
-  ASSERT_EQ(1u, release_stream.order_data->current_order_num());
+  EXPECT_EQ(1u, release_stream.order_data->current_order_num());
   release_stream.EndProcessing();
-  EXPECT_FALSE(release_stream.client->client_state()->IsFenceSyncReleased(1));
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
   EXPECT_EQ(10, test_num);
 
   // Beginning order [4] should immediately trigger the wait although the fence
   // sync is still not released yet.
   release_stream.BeginProcessing();
-  ASSERT_EQ(4u, release_stream.order_data->current_order_num());
-  EXPECT_FALSE(release_stream.client->client_state()->IsFenceSyncReleased(1));
+  EXPECT_EQ(4u, release_stream.order_data->current_order_num());
   EXPECT_EQ(123, test_num);
+  EXPECT_FALSE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
   // Ensure that the wait callback does not get triggered again when it is
   // actually released.
   test_num = 1;
   release_stream.client->ReleaseFenceSync(1);
   EXPECT_EQ(1, test_num);
-}
-
-TEST_F(SyncPointManagerTest, OnWaitCallbackTest) {
-  const CommandBufferNamespace kNamespaceId =
-      gpu::CommandBufferNamespace::GPU_IO;
-  const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
-  const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
-
-  SyncPointStream release_stream(sync_point_manager_.get(), kNamespaceId,
-                                 kBufferId1);
-  SyncPointStream wait_stream(sync_point_manager_.get(), kNamespaceId,
-                              kBufferId2);
-
-  CommandBufferNamespace namespace_id = CommandBufferNamespace::INVALID;
-  CommandBufferId client_id;
-  release_stream.client->SetOnWaitCallback(
-      base::Bind(&SyncPointManagerTest::OnWait, &namespace_id, &client_id));
-
-  release_stream.AllocateOrderNum(sync_point_manager_.get());
-  wait_stream.AllocateOrderNum(sync_point_manager_.get());
-  release_stream.AllocateOrderNum(sync_point_manager_.get());
-
-  wait_stream.BeginProcessing();
-  int test_num = 10;
-  bool valid_wait = wait_stream.client->Wait(
-      release_stream.client->client_state().get(), 1,
-      base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
-  EXPECT_TRUE(valid_wait);
-  EXPECT_EQ(10, test_num);
-  EXPECT_EQ(kNamespaceId, namespace_id);
-  EXPECT_EQ(kBufferId2, client_id);
-
-  release_stream.BeginProcessing();
-  release_stream.client->ReleaseFenceSync(1);
-  EXPECT_EQ(123, test_num);
-
-  wait_stream.EndProcessing();
-
-  namespace_id = CommandBufferNamespace::INVALID;
-  client_id = CommandBufferId();
-  test_num = 10;
-  valid_wait = wait_stream.client->WaitOutOfOrder(
-      release_stream.client->client_state().get(), 2,
-      base::Bind(&SyncPointManagerTest::SetIntegerFunction, &test_num, 123));
-  EXPECT_TRUE(valid_wait);
-  EXPECT_EQ(10, test_num);
-  EXPECT_EQ(kNamespaceId, namespace_id);
-  EXPECT_EQ(kBufferId2, client_id);
-
-  release_stream.client->ReleaseFenceSync(2);
-  EXPECT_EQ(123, test_num);
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 }
 
 }  // namespace gpu
diff --git a/gpu/command_buffer/tests/fuzzer_main.cc b/gpu/command_buffer/tests/fuzzer_main.cc
index 4da1557..2fb7e324 100644
--- a/gpu/command_buffer/tests/fuzzer_main.cc
+++ b/gpu/command_buffer/tests/fuzzer_main.cc
@@ -88,7 +88,7 @@
  public:
   CommandBufferSetup()
       : atexit_manager_(),
-        sync_point_manager_(new SyncPointManager(false)),
+        sync_point_manager_(new SyncPointManager()),
         sync_point_order_data_(SyncPointOrderData::Create()),
         mailbox_manager_(new gles2::MailboxManagerImpl),
         share_group_(new gl::GLShareGroup),
@@ -120,9 +120,9 @@
     gl::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
 #endif
 
-    sync_point_client_ = sync_point_manager_->CreateSyncPointClient(
-        sync_point_order_data_, CommandBufferNamespace::IN_PROCESS,
-        command_buffer_id_);
+    sync_point_client_ = base::MakeUnique<SyncPointClient>(
+        sync_point_manager_.get(), sync_point_order_data_,
+        CommandBufferNamespace::IN_PROCESS, command_buffer_id_);
 
     translator_cache_ = new gles2::ShaderTranslatorCache(gpu_preferences_);
     completeness_cache_ = new gles2::FramebufferCompletenessCache;
@@ -151,8 +151,8 @@
     decoder_->set_engine(executor_.get());
     decoder_->SetFenceSyncReleaseCallback(base::Bind(
         &CommandBufferSetup::OnFenceSyncRelease, base::Unretained(this)));
-    decoder_->SetWaitFenceSyncCallback(base::Bind(
-        &CommandBufferSetup::OnWaitFenceSync, base::Unretained(this)));
+    decoder_->SetWaitSyncTokenCallback(base::Bind(
+        &CommandBufferSetup::OnWaitSyncToken, base::Unretained(this)));
     decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
 
     gles2::ContextCreationAttribHelper attrib_helper;
@@ -241,21 +241,12 @@
     sync_point_client_->ReleaseFenceSync(release);
   }
 
-  bool OnWaitFenceSync(CommandBufferNamespace namespace_id,
-                       CommandBufferId command_buffer_id,
-                       uint64_t release) {
-    CHECK(sync_point_client_);
-    scoped_refptr<gpu::SyncPointClientState> release_state =
-        sync_point_manager_->GetSyncPointClientState(namespace_id,
-                                                     command_buffer_id);
-    if (!release_state)
-      return true;
-
-    if (release_state->IsFenceSyncReleased(release))
-      return true;
-
+  bool OnWaitSyncToken(const SyncToken& sync_token) {
+    CHECK(sync_point_manager_);
+    if (sync_point_manager_->IsSyncTokenReleased(sync_token))
+      return false;
     executor_->SetScheduled(false);
-    return false;
+    return true;
   }
 
   void CreateTransferBuffer(size_t size, int32_t id) {
diff --git a/gpu/command_buffer/tests/gl_fence_sync_unittest.cc b/gpu/command_buffer/tests/gl_fence_sync_unittest.cc
index 65ff1b1..a9b68d3 100644
--- a/gpu/command_buffer/tests/gl_fence_sync_unittest.cc
+++ b/gpu/command_buffer/tests/gl_fence_sync_unittest.cc
@@ -23,7 +23,7 @@
 class GLFenceSyncTest : public testing::Test {
  protected:
   void SetUp() override {
-    sync_point_manager_.reset(new SyncPointManager(false));
+    sync_point_manager_.reset(new SyncPointManager());
 
     GLManager::Options options;
     options.sync_point_manager = sync_point_manager_.get();
@@ -53,20 +53,11 @@
   ASSERT_TRUE(GL_NO_ERROR == glGetError());
 
   // Make sure it is actually released.
-  scoped_refptr<SyncPointClientState> gl1_client_state =
-      sync_point_manager_->GetSyncPointClientState(gl1_.GetNamespaceID(),
-                                                   gl1_.GetCommandBufferID());
-  EXPECT_TRUE(gl1_client_state->IsFenceSyncReleased(fence_sync));
+  EXPECT_TRUE(sync_point_manager_->IsSyncTokenReleased(sync_token));
 
   gl2_.MakeCurrent();
   glWaitSyncTokenCHROMIUM(sync_token.GetConstData());
   glFinish();
-
-  // gl2 should not have released anything.
-  scoped_refptr<SyncPointClientState> gl2_client_state =
-      sync_point_manager_->GetSyncPointClientState(gl2_.GetNamespaceID(),
-                                                   gl2_.GetCommandBufferID());
-  EXPECT_EQ(0u, gl2_client_state->fence_sync_release());
 }
 
 static void TestCallback(int* storage, int assign) {
diff --git a/gpu/command_buffer/tests/gl_manager.cc b/gpu/command_buffer/tests/gl_manager.cc
index 73463f8..06b238d 100644
--- a/gpu/command_buffer/tests/gl_manager.cc
+++ b/gpu/command_buffer/tests/gl_manager.cc
@@ -185,30 +185,11 @@
 scoped_refptr<gl::GLSurface>* GLManager::base_surface_;
 scoped_refptr<gl::GLContext>* GLManager::base_context_;
 
-GLManager::Options::Options()
-    : size(4, 4),
-      sync_point_manager(NULL),
-      share_group_manager(NULL),
-      share_mailbox_manager(NULL),
-      virtual_manager(NULL),
-      bind_generates_resource(false),
-      lose_context_when_out_of_memory(false),
-      context_lost_allowed(false),
-      context_type(gles2::CONTEXT_TYPE_OPENGLES2),
-      force_shader_name_hashing(false),
-      multisampled(false),
-      backbuffer_alpha(true),
-      image_factory(nullptr),
-      preserve_backbuffer(false) {}
+GLManager::Options::Options() = default;
 
 GLManager::GLManager()
-    : sync_point_manager_(nullptr),
-      context_lost_allowed_(false),
-      pause_commands_(false),
-      paused_order_num_(0),
-      command_buffer_id_(
-          CommandBufferId::FromUnsafeValue(g_next_command_buffer_id++)),
-      next_fence_sync_release_(1) {
+    : command_buffer_id_(
+          CommandBufferId::FromUnsafeValue(g_next_command_buffer_id++)) {
   SetupBaseContext();
 }
 
@@ -369,13 +350,14 @@
   if (options.sync_point_manager) {
     sync_point_manager_ = options.sync_point_manager;
     sync_point_order_data_ = SyncPointOrderData::Create();
-    sync_point_client_ = sync_point_manager_->CreateSyncPointClient(
-        sync_point_order_data_, GetNamespaceID(), GetCommandBufferID());
+    sync_point_client_ = base::MakeUnique<SyncPointClient>(
+        sync_point_manager_, sync_point_order_data_, GetNamespaceID(),
+        GetCommandBufferID());
 
     decoder_->SetFenceSyncReleaseCallback(
         base::Bind(&GLManager::OnFenceSyncRelease, base::Unretained(this)));
-    decoder_->SetWaitFenceSyncCallback(
-        base::Bind(&GLManager::OnWaitFenceSync, base::Unretained(this)));
+    decoder_->SetWaitSyncTokenCallback(
+        base::Bind(&GLManager::OnWaitSyncToken, base::Unretained(this)));
   } else {
     sync_point_manager_ = nullptr;
     sync_point_order_data_ = nullptr;
@@ -428,25 +410,16 @@
 
 void GLManager::OnFenceSyncRelease(uint64_t release) {
   DCHECK(sync_point_client_);
-  DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
   command_buffer_->SetReleaseCount(release);
   sync_point_client_->ReleaseFenceSync(release);
 }
 
-bool GLManager::OnWaitFenceSync(gpu::CommandBufferNamespace namespace_id,
-                                gpu::CommandBufferId command_buffer_id,
-                                uint64_t release) {
-  DCHECK(sync_point_client_);
-  scoped_refptr<gpu::SyncPointClientState> release_state =
-      sync_point_manager_->GetSyncPointClientState(namespace_id,
-                                                   command_buffer_id);
-  if (!release_state)
-    return true;
-
+bool GLManager::OnWaitSyncToken(const SyncToken& sync_token) {
+  DCHECK(sync_point_manager_);
   // GLManager does not support being multithreaded at this point, so the fence
   // sync must be released by the time wait is called.
-  DCHECK(release_state->IsFenceSyncReleased(release));
-  return true;
+  DCHECK(sync_point_manager_->IsSyncTokenReleased(sync_token));
+  return false;
 }
 
 void GLManager::MakeCurrent() {
@@ -636,19 +609,16 @@
 void GLManager::SignalSyncToken(const gpu::SyncToken& sync_token,
                                 const base::Closure& callback) {
   if (sync_point_manager_) {
-    scoped_refptr<gpu::SyncPointClientState> release_state =
-        sync_point_manager_->GetSyncPointClientState(
-            sync_token.namespace_id(), sync_token.command_buffer_id());
-
-    if (release_state) {
-      sync_point_client_->WaitOutOfOrder(release_state.get(),
-                                         sync_token.release_count(), callback);
-      return;
-    }
+    DCHECK(!paused_order_num_);
+    uint32_t order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
+        sync_point_manager_);
+    sync_point_order_data_->BeginProcessingOrderNumber(order_num);
+    if (!sync_point_client_->Wait(sync_token, callback))
+      callback.Run();
+    sync_point_order_data_->FinishProcessingOrderNumber(order_num);
+  } else {
+    callback.Run();
   }
-
-  // Something went wrong, just run the callback now.
-  callback.Run();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
diff --git a/gpu/command_buffer/tests/gl_manager.h b/gpu/command_buffer/tests/gl_manager.h
index b4ecb3e..b8877d61 100644
--- a/gpu/command_buffer/tests/gl_manager.h
+++ b/gpu/command_buffer/tests/gl_manager.h
@@ -54,32 +54,32 @@
   struct Options {
     Options();
     // The size of the backbuffer.
-    gfx::Size size;
+    gfx::Size size = gfx::Size(4, 4);
     // If not null will have a corresponding sync point manager.
-    SyncPointManager* sync_point_manager;
+    SyncPointManager* sync_point_manager = nullptr;
     // If not null will share resources with this context.
-    GLManager* share_group_manager;
+    GLManager* share_group_manager = nullptr;
     // If not null will share a mailbox manager with this context.
-    GLManager* share_mailbox_manager;
+    GLManager* share_mailbox_manager = nullptr;
     // If not null will create a virtual manager based on this context.
-    GLManager* virtual_manager;
+    GLManager* virtual_manager = nullptr;
     // Whether or not glBindXXX generates a resource.
-    bool bind_generates_resource;
+    bool bind_generates_resource = false;
     // Whether or not the context is auto-lost when GL_OUT_OF_MEMORY occurs.
-    bool lose_context_when_out_of_memory;
+    bool lose_context_when_out_of_memory = false;
     // Whether or not it's ok to lose the context.
-    bool context_lost_allowed;
-    gles2::ContextType context_type;
+    bool context_lost_allowed = false;
+    gles2::ContextType context_type = gles2::CONTEXT_TYPE_OPENGLES2;
     // Force shader name hashing for all context types.
-    bool force_shader_name_hashing;
+    bool force_shader_name_hashing = false;
     // Whether the buffer is multisampled.
-    bool multisampled;
+    bool multisampled = false;
     // Whether the backbuffer has an alpha channel.
-    bool backbuffer_alpha;
+    bool backbuffer_alpha = true;
     // The ImageFactory to use to generate images for the backbuffer.
-    gpu::ImageFactory* image_factory;
+    gpu::ImageFactory* image_factory = nullptr;
     // Whether to preserve the backbuffer after a call to SwapBuffers().
-    bool preserve_backbuffer;
+    bool preserve_backbuffer = false;
   };
   GLManager();
   ~GLManager() override;
@@ -153,13 +153,11 @@
   bool GetBufferChanged(int32_t transfer_buffer_id);
   void SetupBaseContext();
   void OnFenceSyncRelease(uint64_t release);
-  bool OnWaitFenceSync(gpu::CommandBufferNamespace namespace_id,
-                       gpu::CommandBufferId command_buffer_id,
-                       uint64_t release);
+  bool OnWaitSyncToken(const SyncToken& sync_token);
 
   gpu::GpuPreferences gpu_preferences_;
 
-  SyncPointManager* sync_point_manager_;  // Non-owning.
+  SyncPointManager* sync_point_manager_ = nullptr;  // Non-owning.
 
   scoped_refptr<SyncPointOrderData> sync_point_order_data_;
   std::unique_ptr<SyncPointClient> sync_point_client_;
@@ -173,12 +171,12 @@
   std::unique_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   std::unique_ptr<TransferBuffer> transfer_buffer_;
   std::unique_ptr<gles2::GLES2Implementation> gles2_implementation_;
-  bool context_lost_allowed_;
-  bool pause_commands_;
-  uint32_t paused_order_num_;
+  bool context_lost_allowed_ = false;
+  bool pause_commands_ = false;
+  uint32_t paused_order_num_ = 0;
 
   const CommandBufferId command_buffer_id_;
-  uint64_t next_fence_sync_release_;
+  uint64_t next_fence_sync_release_ = 1;
 
   bool use_iosurface_memory_buffers_ = false;
 
diff --git a/gpu/ipc/in_process_command_buffer.cc b/gpu/ipc/in_process_command_buffer.cc
index 4ae663a..ec3464e 100644
--- a/gpu/ipc/in_process_command_buffer.cc
+++ b/gpu/ipc/in_process_command_buffer.cc
@@ -77,8 +77,7 @@
 class GpuInProcessThreadHolder : public base::Thread {
  public:
   GpuInProcessThreadHolder()
-      : base::Thread("GpuThread"),
-        sync_point_manager_(new SyncPointManager(false)) {
+      : base::Thread("GpuThread"), sync_point_manager_(new SyncPointManager()) {
     Start();
   }
 
@@ -349,8 +348,9 @@
   }
 
   sync_point_order_data_ = SyncPointOrderData::Create();
-  sync_point_client_ = service_->sync_point_manager()->CreateSyncPointClient(
-      sync_point_order_data_, GetNamespaceID(), GetCommandBufferID());
+  sync_point_client_ = base::MakeUnique<SyncPointClient>(
+      service_->sync_point_manager(), sync_point_order_data_, GetNamespaceID(),
+      GetCommandBufferID());
 
   if (service_->UseVirtualizedGLContexts() ||
       decoder_->GetContextGroup()
@@ -417,8 +417,8 @@
   decoder_->SetFenceSyncReleaseCallback(
       base::Bind(&InProcessCommandBuffer::FenceSyncReleaseOnGpuThread,
                  base::Unretained(this)));
-  decoder_->SetWaitFenceSyncCallback(
-      base::Bind(&InProcessCommandBuffer::WaitFenceSyncOnGpuThread,
+  decoder_->SetWaitSyncTokenCallback(
+      base::Bind(&InProcessCommandBuffer::WaitSyncTokenOnGpuThread,
                  base::Unretained(this)));
   decoder_->SetDescheduleUntilFinishedCallback(
       base::Bind(&InProcessCommandBuffer::DescheduleUntilFinishedOnGpuThread,
@@ -801,9 +801,8 @@
     }
   }
 
-  if (fence_sync) {
+  if (fence_sync)
     sync_point_client_->ReleaseFenceSync(fence_sync);
-  }
 }
 
 void InProcessCommandBuffer::DestroyImage(int32_t id) {
@@ -828,81 +827,57 @@
 }
 
 void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint64_t release) {
-  DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
+  SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
+                       GetCommandBufferID(), release);
+
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
-  if (mailbox_manager->UsesSync()) {
-    SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
-                         GetCommandBufferID(), release);
-    mailbox_manager->PushTextureUpdates(sync_token);
-  }
+  mailbox_manager->PushTextureUpdates(sync_token);
 
   sync_point_client_->ReleaseFenceSync(release);
 }
 
-bool InProcessCommandBuffer::WaitFenceSyncOnGpuThread(
-    gpu::CommandBufferNamespace namespace_id,
-    gpu::CommandBufferId command_buffer_id,
-    uint64_t release) {
+bool InProcessCommandBuffer::WaitSyncTokenOnGpuThread(
+    const SyncToken& sync_token) {
   DCHECK(!waiting_for_sync_point_);
   gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
   DCHECK(sync_point_manager);
 
-  scoped_refptr<gpu::SyncPointClientState> release_state =
-      sync_point_manager->GetSyncPointClientState(namespace_id,
-                                                  command_buffer_id);
-
-  if (!release_state)
-    return true;
+  gles2::MailboxManager* mailbox_manager =
+      decoder_->GetContextGroup()->mailbox_manager();
+  DCHECK(mailbox_manager);
 
   if (service_->BlockThreadOnWaitSyncToken()) {
-    if (!release_state->IsFenceSyncReleased(release)) {
-      // Use waitable event which is signalled when the release fence is
-      // released.
-      sync_point_client_->Wait(
-          release_state.get(), release,
-          base::Bind(&base::WaitableEvent::Signal,
-                     base::Unretained(&fence_sync_wait_event_)));
+    // Wait if sync point wait is valid.
+    if (sync_point_client_->Wait(
+            sync_token,
+            base::Bind(&base::WaitableEvent::Signal,
+                       base::Unretained(&fence_sync_wait_event_)))) {
       fence_sync_wait_event_.Wait();
     }
 
-    gles2::MailboxManager* mailbox_manager =
-        decoder_->GetContextGroup()->mailbox_manager();
-    SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
     mailbox_manager->PullTextureUpdates(sync_token);
-    return true;
+    return false;
   }
 
-  if (release_state->IsFenceSyncReleased(release)) {
-    gles2::MailboxManager* mailbox_manager =
-        decoder_->GetContextGroup()->mailbox_manager();
-    SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
+  waiting_for_sync_point_ = sync_point_client_->Wait(
+      sync_token,
+      base::Bind(&InProcessCommandBuffer::OnWaitSyncTokenCompleted,
+                 gpu_thread_weak_ptr_factory_.GetWeakPtr(), sync_token));
+  if (!waiting_for_sync_point_) {
     mailbox_manager->PullTextureUpdates(sync_token);
-    return true;
+    return false;
   }
 
-  waiting_for_sync_point_ = true;
-  sync_point_client_->Wait(
-      release_state.get(), release,
-      base::Bind(&InProcessCommandBuffer::OnWaitFenceSyncCompleted,
-                 gpu_thread_weak_ptr_factory_.GetWeakPtr(), namespace_id,
-                 command_buffer_id, release));
-
-  if (!waiting_for_sync_point_)
-    return true;
-
   executor_->SetScheduled(false);
-  return false;
+  return true;
 }
 
-void InProcessCommandBuffer::OnWaitFenceSyncCompleted(
-    CommandBufferNamespace namespace_id,
-    CommandBufferId command_buffer_id,
-    uint64_t release) {
+void InProcessCommandBuffer::OnWaitSyncTokenCompleted(
+    const SyncToken& sync_token) {
   DCHECK(waiting_for_sync_point_);
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
-  SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
   mailbox_manager->PullTextureUpdates(sync_token);
   waiting_for_sync_point_ = false;
   executor_->SetScheduled(true);
@@ -931,20 +906,8 @@
 void InProcessCommandBuffer::SignalSyncTokenOnGpuThread(
     const SyncToken& sync_token,
     const base::Closure& callback) {
-  gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
-  DCHECK(sync_point_manager);
-
-  scoped_refptr<gpu::SyncPointClientState> release_state =
-      sync_point_manager->GetSyncPointClientState(
-          sync_token.namespace_id(), sync_token.command_buffer_id());
-
-  if (!release_state) {
+  if (!sync_point_client_->Wait(sync_token, WrapCallback(callback)))
     callback.Run();
-    return;
-  }
-
-  sync_point_client_->WaitOutOfOrder(
-      release_state.get(), sync_token.release_count(), WrapCallback(callback));
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
@@ -1013,7 +976,7 @@
                                              const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(
-      true,
+      false,
       base::Bind(&InProcessCommandBuffer::SignalSyncTokenOnGpuThread,
                  base::Unretained(this), sync_token, WrapCallback(callback)));
 }
diff --git a/gpu/ipc/in_process_command_buffer.h b/gpu/ipc/in_process_command_buffer.h
index 02b1366..6bc7066 100644
--- a/gpu/ipc/in_process_command_buffer.h
+++ b/gpu/ipc/in_process_command_buffer.h
@@ -237,12 +237,8 @@
   void ProcessTasksOnGpuThread();
   void CheckSequencedThread();
   void FenceSyncReleaseOnGpuThread(uint64_t release);
-  bool WaitFenceSyncOnGpuThread(gpu::CommandBufferNamespace namespace_id,
-                                gpu::CommandBufferId command_buffer_id,
-                                uint64_t release);
-  void OnWaitFenceSyncCompleted(CommandBufferNamespace namespace_id,
-                                CommandBufferId command_buffer_id,
-                                uint64_t release);
+  bool WaitSyncTokenOnGpuThread(const SyncToken& sync_token);
+  void OnWaitSyncTokenCompleted(const SyncToken& sync_token);
   void DescheduleUntilFinishedOnGpuThread();
   void RescheduleAfterFinishedOnGpuThread();
   void SignalSyncTokenOnGpuThread(const SyncToken& sync_token,
diff --git a/gpu/ipc/service/gpu_channel_manager.cc b/gpu/ipc/service/gpu_channel_manager.cc
index 2ca665f..a6a099c6 100644
--- a/gpu/ipc/service/gpu_channel_manager.cc
+++ b/gpu/ipc/service/gpu_channel_manager.cc
@@ -64,8 +64,6 @@
       mailbox_manager_(gles2::MailboxManager::Create(gpu_preferences)),
       gpu_memory_manager_(this),
       sync_point_manager_(sync_point_manager),
-      sync_point_client_waiter_(
-          sync_point_manager->CreateSyncPointClientWaiter()),
       gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
       gpu_feature_info_(gpu_feature_info),
       exiting_for_lost_context_(false),
@@ -174,21 +172,13 @@
     gfx::GpuMemoryBufferId id,
     int client_id,
     const SyncToken& sync_token) {
-  if (sync_token.HasData()) {
-    scoped_refptr<SyncPointClientState> release_state =
-        sync_point_manager()->GetSyncPointClientState(
-            sync_token.namespace_id(), sync_token.command_buffer_id());
-    if (release_state) {
-      sync_point_client_waiter_->WaitOutOfOrder(
-          release_state.get(), sync_token.release_count(),
+  if (!sync_point_manager_->WaitOutOfOrder(
+          sync_token,
           base::Bind(&GpuChannelManager::InternalDestroyGpuMemoryBuffer,
-                     base::Unretained(this), id, client_id));
-      return;
-    }
+                     base::Unretained(this), id, client_id))) {
+    // No sync token or invalid sync token, destroy immediately.
+    InternalDestroyGpuMemoryBuffer(id, client_id);
   }
-
-  // No sync token or invalid sync token, destroy immediately.
-  InternalDestroyGpuMemoryBuffer(id, client_id);
 }
 
 void GpuChannelManager::PopulateShaderCache(const std::string& program_proto) {
diff --git a/gpu/ipc/service/gpu_channel_manager.h b/gpu/ipc/service/gpu_channel_manager.h
index 5ca1c677..01301b27 100644
--- a/gpu/ipc/service/gpu_channel_manager.h
+++ b/gpu/ipc/service/gpu_channel_manager.h
@@ -39,7 +39,6 @@
 namespace gpu {
 struct GpuPreferences;
 class PreemptionFlag;
-class SyncPointClient;
 class SyncPointManager;
 struct SyncToken;
 namespace gles2 {
@@ -188,7 +187,6 @@
   GpuMemoryManager gpu_memory_manager_;
   // SyncPointManager guaranteed to outlive running MessageLoop.
   SyncPointManager* sync_point_manager_;
-  std::unique_ptr<SyncPointClient> sync_point_client_waiter_;
   std::unique_ptr<gles2::ProgramCache> program_cache_;
   scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache_;
   scoped_refptr<gles2::FramebufferCompletenessCache>
diff --git a/gpu/ipc/service/gpu_channel_test_common.cc b/gpu/ipc/service/gpu_channel_test_common.cc
index 3d199eb..85b207ee 100644
--- a/gpu/ipc/service/gpu_channel_test_common.cc
+++ b/gpu/ipc/service/gpu_channel_test_common.cc
@@ -132,7 +132,7 @@
 GpuChannelTestCommon::GpuChannelTestCommon()
     : task_runner_(new base::TestSimpleTaskRunner),
       io_task_runner_(new base::TestSimpleTaskRunner),
-      sync_point_manager_(new SyncPointManager(false)),
+      sync_point_manager_(new SyncPointManager()),
       channel_manager_delegate_(new TestGpuChannelManagerDelegate()) {}
 
 GpuChannelTestCommon::~GpuChannelTestCommon() {
diff --git a/gpu/ipc/service/gpu_command_buffer_stub.cc b/gpu/ipc/service/gpu_command_buffer_stub.cc
index 1cbea32..ffa0a3c 100644
--- a/gpu/ipc/service/gpu_command_buffer_stub.cc
+++ b/gpu/ipc/service/gpu_command_buffer_stub.cc
@@ -276,7 +276,10 @@
       message.type() != GpuCommandBufferMsg_WaitForTokenInRange::ID &&
       message.type() != GpuCommandBufferMsg_WaitForGetOffsetInRange::ID &&
       message.type() != GpuCommandBufferMsg_RegisterTransferBuffer::ID &&
-      message.type() != GpuCommandBufferMsg_DestroyTransferBuffer::ID) {
+      message.type() != GpuCommandBufferMsg_DestroyTransferBuffer::ID &&
+      message.type() != GpuCommandBufferMsg_WaitSyncToken::ID &&
+      message.type() != GpuCommandBufferMsg_SignalSyncToken::ID &&
+      message.type() != GpuCommandBufferMsg_SignalQuery::ID) {
     if (!MakeCurrent())
       return false;
     have_context = true;
@@ -642,7 +645,8 @@
   decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                       decoder_.get()));
-  sync_point_client_ = channel_->sync_point_manager()->CreateSyncPointClient(
+  sync_point_client_ = base::MakeUnique<SyncPointClient>(
+      channel_->sync_point_manager(),
       channel_->GetSyncPointOrderData(stream_id_),
       CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
@@ -783,8 +787,8 @@
                  base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &GpuCommandBufferStub::OnFenceSyncRelease, base::Unretained(this)));
-  decoder_->SetWaitFenceSyncCallback(base::Bind(
-      &GpuCommandBufferStub::OnWaitFenceSync, base::Unretained(this)));
+  decoder_->SetWaitSyncTokenCallback(base::Bind(
+      &GpuCommandBufferStub::OnWaitSyncToken, base::Unretained(this)));
   decoder_->SetDescheduleUntilFinishedCallback(
       base::Bind(&GpuCommandBufferStub::OnDescheduleUntilFinished,
                  base::Unretained(this)));
@@ -1002,34 +1006,12 @@
   executor_->PutChanged();
 }
 
-void GpuCommandBufferStub::PullTextureUpdates(
-    CommandBufferNamespace namespace_id,
-    CommandBufferId command_buffer_id,
-    uint32_t release) {
-  gles2::MailboxManager* mailbox_manager =
-      context_group_->mailbox_manager();
-  if (mailbox_manager->UsesSync() && MakeCurrent()) {
-    SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
-    mailbox_manager->PullTextureUpdates(sync_token);
-  }
-}
-
-void GpuCommandBufferStub::OnWaitSyncToken(const SyncToken& sync_token) {
-  OnWaitFenceSync(sync_token.namespace_id(), sync_token.command_buffer_id(),
-                  sync_token.release_count());
-}
-
 void GpuCommandBufferStub::OnSignalSyncToken(const SyncToken& sync_token,
                                              uint32_t id) {
-  scoped_refptr<SyncPointClientState> release_state =
-      channel_->sync_point_manager()->GetSyncPointClientState(
-          sync_token.namespace_id(), sync_token.command_buffer_id());
-
-  if (release_state) {
-    sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
-                             base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                                        this->AsWeakPtr(), id));
-  } else {
+  if (!sync_point_client_->WaitNonThreadSafe(
+          sync_token, channel_->task_runner(),
+          base::Bind(&GpuCommandBufferStub::OnSignalAck, this->AsWeakPtr(),
+                     id))) {
     OnSignalAck(id);
   }
 }
@@ -1058,18 +1040,11 @@
 }
 
 void GpuCommandBufferStub::OnFenceSyncRelease(uint64_t release) {
-  if (sync_point_client_->client_state()->IsFenceSyncReleased(release)) {
-    DLOG(ERROR) << "Fence Sync has already been released.";
-    return;
-  }
-
-  gles2::MailboxManager* mailbox_manager =
-      context_group_->mailbox_manager();
-  if (mailbox_manager->UsesSync() && MakeCurrent()) {
-    SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0,
-                              command_buffer_id_, release);
+  SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0, command_buffer_id_,
+                       release);
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
+  if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PushTextureUpdates(sync_token);
-  }
 
   command_buffer_->SetReleaseCount(release);
   sync_point_client_->ReleaseFenceSync(release);
@@ -1090,50 +1065,40 @@
   channel_->OnStreamRescheduled(stream_id_, true);
 }
 
-bool GpuCommandBufferStub::OnWaitFenceSync(
-    CommandBufferNamespace namespace_id,
-    CommandBufferId command_buffer_id,
-    uint64_t release) {
+bool GpuCommandBufferStub::OnWaitSyncToken(const SyncToken& sync_token) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(executor_->scheduled());
+  TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncToken", this, "GpuCommandBufferStub",
+                           this);
 
-  scoped_refptr<SyncPointClientState> release_state =
-      channel_->sync_point_manager()->GetSyncPointClientState(
-          namespace_id, command_buffer_id);
+  waiting_for_sync_point_ = sync_point_client_->WaitNonThreadSafe(
+      sync_token, channel_->task_runner(),
+      base::Bind(&GpuCommandBufferStub::OnWaitSyncTokenCompleted, AsWeakPtr(),
+                 sync_token));
 
-  if (!release_state)
-    return true;
-
-  if (release_state->IsFenceSyncReleased(release)) {
-    PullTextureUpdates(namespace_id, command_buffer_id, release);
+  if (waiting_for_sync_point_) {
+    executor_->SetScheduled(false);
+    channel_->OnStreamRescheduled(stream_id_, false);
     return true;
   }
 
-  TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
-                           this);
-  waiting_for_sync_point_ = true;
-  sync_point_client_->WaitNonThreadSafe(
-      release_state.get(), release, channel_->task_runner(),
-      base::Bind(&GpuCommandBufferStub::OnWaitFenceSyncCompleted,
-                 this->AsWeakPtr(), namespace_id, command_buffer_id, release));
-
-  if (!waiting_for_sync_point_)
-    return true;
-
-  executor_->SetScheduled(false);
-  channel_->OnStreamRescheduled(stream_id_, false);
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
+  if (mailbox_manager->UsesSync() && MakeCurrent())
+    mailbox_manager->PullTextureUpdates(sync_token);
   return false;
 }
 
-void GpuCommandBufferStub::OnWaitFenceSyncCompleted(
-    CommandBufferNamespace namespace_id,
-    CommandBufferId command_buffer_id,
-    uint64_t release) {
+void GpuCommandBufferStub::OnWaitSyncTokenCompleted(
+    const SyncToken& sync_token) {
   DCHECK(waiting_for_sync_point_);
-  TRACE_EVENT_ASYNC_END1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
-                         this);
-  PullTextureUpdates(namespace_id, command_buffer_id, release);
+  TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncTokenCompleted", this,
+                         "GpuCommandBufferStub", this);
   waiting_for_sync_point_ = false;
+
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
+  if (mailbox_manager->UsesSync() && MakeCurrent())
+    mailbox_manager->PullTextureUpdates(sync_token);
+
   executor_->SetScheduled(true);
   channel_->OnStreamRescheduled(stream_id_, true);
 }
@@ -1181,13 +1146,8 @@
     return;
 
   image_manager->AddImage(image.get(), id);
-  if (image_release_count) {
-    DLOG_IF(ERROR,
-            image_release_count !=
-                sync_point_client_->client_state()->fence_sync_release() + 1)
-        << "Client released fences out of order.";
+  if (image_release_count)
     sync_point_client_->ReleaseFenceSync(image_release_count);
-  }
 }
 
 void GpuCommandBufferStub::OnDestroyImage(int32_t id) {
@@ -1211,14 +1171,14 @@
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
-  IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
-      route_id_, console_message);
+  IPC::Message* msg =
+      new GpuCommandBufferMsg_ConsoleMsg(route_id_, console_message);
   msg->set_unblock(true);
   Send(msg);
 }
 
-void GpuCommandBufferStub::SendCachedShader(
-    const std::string& key, const std::string& shader) {
+void GpuCommandBufferStub::SendCachedShader(const std::string& key,
+                                            const std::string& shader) {
   channel_->CacheShader(key, shader);
 }
 
diff --git a/gpu/ipc/service/gpu_command_buffer_stub.h b/gpu/ipc/service/gpu_command_buffer_stub.h
index 75dba0a..3803172 100644
--- a/gpu/ipc/service/gpu_command_buffer_stub.h
+++ b/gpu/ipc/service/gpu_command_buffer_stub.h
@@ -167,21 +167,16 @@
                                 uint32_t size);
   void OnDestroyTransferBuffer(int32_t id);
   void OnGetTransferBuffer(int32_t id, IPC::Message* reply_message);
+  bool OnWaitSyncToken(const SyncToken& sync_token);
 
   void OnEnsureBackbuffer();
 
-  void OnWaitSyncToken(const SyncToken& sync_token);
   void OnSignalSyncToken(const SyncToken& sync_token, uint32_t id);
   void OnSignalAck(uint32_t id);
   void OnSignalQuery(uint32_t query, uint32_t id);
 
   void OnFenceSyncRelease(uint64_t release);
-  bool OnWaitFenceSync(CommandBufferNamespace namespace_id,
-                       CommandBufferId command_buffer_id,
-                       uint64_t release);
-  void OnWaitFenceSyncCompleted(CommandBufferNamespace namespace_id,
-                                CommandBufferId command_buffer_id,
-                                uint64_t release);
+  void OnWaitSyncTokenCompleted(const SyncToken& sync_token);
 
   void OnDescheduleUntilFinished();
   void OnRescheduleAfterFinished();
@@ -211,9 +206,6 @@
 
   bool CheckContextLost();
   void CheckCompleteWaits();
-  void PullTextureUpdates(CommandBufferNamespace namespace_id,
-                          CommandBufferId command_buffer_id,
-                          uint32_t release);
 
   // The lifetime of objects of this class is managed by a GpuChannel. The
   // GpuChannels destroy all the GpuCommandBufferStubs that they own when they
diff --git a/services/ui/gpu/gpu_service.cc b/services/ui/gpu/gpu_service.cc
index c0e224e..f5e5b1f 100644
--- a/services/ui/gpu/gpu_service.cc
+++ b/services/ui/gpu/gpu_service.cc
@@ -83,9 +83,7 @@
 
   sync_point_manager_ = sync_point_manager;
   if (!sync_point_manager_) {
-    const bool allow_threaded_wait = false;
-    owned_sync_point_manager_ =
-        base::MakeUnique<gpu::SyncPointManager>(allow_threaded_wait);
+    owned_sync_point_manager_ = base::MakeUnique<gpu::SyncPointManager>();
     sync_point_manager_ = owned_sync_point_manager_.get();
   }