Removed last references to old sync points.

gpu/command_buffer/service/sync_point_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/sync_point_manager.h"
 
 #include <limits.h>
 #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/rand_util.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 
 namespace gpu {
 
-static const int kMaxSyncBase = INT_MAX;
-
 namespace {
 
 void RunOnThread(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                  const base::Closure& callback) {
   if (task_runner->BelongsToCurrentThread()) {
     callback.Run();
   } else {
     task_runner->PostTask(FROM_HERE, callback);
   }
 }
@@ skipping 298 matching lines @@
 
 SyncPointClient::SyncPointClient(SyncPointManager* sync_point_manager,
                                  scoped_refptr<SyncPointOrderData> order_data,
                                  CommandBufferNamespace namespace_id,
                                  uint64_t 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)
-    : // To reduce the risk that a sync point created in a previous GPU process
-      // will be in flight in the next GPU process, randomize the starting sync
-      // point number. http://crbug.com/373452
-      next_sync_point_(base::RandInt(1, kMaxSyncBase)) {
+SyncPointManager::SyncPointManager(bool allow_threaded_wait) {
   global_order_num_.GetNext();
 }
 
 SyncPointManager::~SyncPointManager() {
   for (const ClientMap& client_map : client_maps_) {
     DCHECK(client_map.empty());
   }
 }
 
 scoped_ptr<SyncPointClient> SyncPointManager::CreateSyncPointClient(
@@ skipping 24 matching lines @@
     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;
 }
 
-uint32_t SyncPointManager::GenerateSyncPoint() {
-  base::AutoLock lock(lock_);
-  uint32_t sync_point = next_sync_point_++;
-  // When an integer overflow occurs, don't return 0.
-  if (!sync_point)
-    sync_point = next_sync_point_++;
-
-  // Note: wrapping would take days for a buggy/compromized renderer that would
-  // insert sync points in a loop, but if that were to happen, better explicitly
-  // crash the GPU process than risk worse.
-  // For normal operation (at most a few per frame), it would take ~a year to
-  // wrap.
-  CHECK(sync_point_map_.find(sync_point) == sync_point_map_.end());
-  sync_point_map_.insert(std::make_pair(sync_point, ClosureList()));
-  return sync_point;
-}
-
-void SyncPointManager::RetireSyncPoint(uint32_t sync_point) {
-  ClosureList list;
-  {
-    base::AutoLock lock(lock_);
-    SyncPointMap::iterator it = sync_point_map_.find(sync_point);
-    if (it == sync_point_map_.end()) {
-      LOG(ERROR) << "Attempted to retire sync point that"
-                    " didn't exist or was already retired.";
-      return;
-    }
-    list.swap(it->second);
-    sync_point_map_.erase(it);
-  }
-  for (ClosureList::iterator i = list.begin(); i != list.end(); ++i)
-    i->Run();
-}
-
-void SyncPointManager::AddSyncPointCallback(uint32_t sync_point,
-                                            const base::Closure& callback) {
-  {
-    base::AutoLock lock(lock_);
-    SyncPointMap::iterator it = sync_point_map_.find(sync_point);
-    if (it != sync_point_map_.end()) {
-      it->second.push_back(callback);
-      return;
-    }
-  }
-  callback.Run();
-}
-
-bool SyncPointManager::IsSyncPointRetired(uint32_t sync_point) {
-  base::AutoLock lock(lock_);
-  return IsSyncPointRetiredLocked(sync_point);
-}
-
-bool SyncPointManager::IsSyncPointRetiredLocked(uint32_t sync_point) {
-  lock_.AssertAcquired();
-  return sync_point_map_.find(sync_point) == sync_point_map_.end();
-}
-
 uint32_t SyncPointManager::GenerateOrderNumber() {
   return global_order_num_.GetNext();
 }
 
 void SyncPointManager::DestroySyncPointClient(
     CommandBufferNamespace namespace_id, uint64_t 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);
 }
 
 }  // namespace gpu