gpu: Cleanup callback types (part 3).

Remove usage of deprecated base::Bind, base::Callback, base::Closure,
base::CancelableCallback and base::CancelableClosure types from gpu/*
services/ws/public/gpu/* and ui/gl/*. Where possible convert to the
corresponding once type. Otherwise replace with the repeating type which
is equivalent to the deprecated type.

Bug: 714018
Change-Id: If1bf4a30616d746e3c422fdb2644e48798896336
Reviewed-on: https://chromium-review.googlesource.com/c/1450537
Reviewed-by: Jonathan Backer <backer@chromium.org>
Commit-Queue: kylechar <kylechar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#628856}

gpu/command_buffer/service/gpu_tracer_unittest.cc

@@ -53,7 +53,7 @@ class GPUTracerTester : public GPUTracer {
  public:
   explicit GPUTracerTester(GLES2Decoder* decoder)
       : GPUTracer(decoder), tracing_enabled_(0) {
-    gpu_timing_client_->SetCpuTimeForTesting(base::Bind(&FakeCpuTime));
+    gpu_timing_client_->SetCpuTimeForTesting(base::BindRepeating(&FakeCpuTime));
 
     // Force tracing to be dependent on our mock variable here.
     gpu_trace_srv_category = &tracing_enabled_;
@@ -100,7 +100,7 @@ class BaseGpuTest : public GpuServiceTest {
       gl_fake_queries_.ExpectNoDisjointCalls(*gl_);
 
     gpu_timing_client_ = GetGLContext()->CreateGPUTimingClient();
-    gpu_timing_client_->SetCpuTimeForTesting(base::Bind(&FakeCpuTime));
+    gpu_timing_client_->SetCpuTimeForTesting(base::BindRepeating(&FakeCpuTime));
     gl_fake_queries_.Reset();
   }
 

gpu/command_buffer/service/query_manager_unittest.cc

@@ -562,7 +562,7 @@ TEST_F(QueryManagerTest, TimeElapsedQuery) {
   const base::subtle::Atomic32 kSubmitCount = 123;
   gl::GPUTimingFake fake_timing_queries;
   decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
-      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));
+      base::BindRepeating(&gl::GPUTimingFake::GetFakeCPUTime));
 
   QueryManager::Query* query = CreateQuery(
       kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
@@ -594,7 +594,7 @@ TEST_F(QueryManagerTest, TimeElapsedPauseResume) {
   const base::subtle::Atomic32 kSubmitCount = 123;
   gl::GPUTimingFake fake_timing_queries;
   decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
-      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));
+      base::BindRepeating(&gl::GPUTimingFake::GetFakeCPUTime));
 
   QueryManager::Query* query = CreateQuery(
       kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
@@ -699,7 +699,7 @@ TEST_F(QueryManagerTest, TimeStampQuery) {
   gl::GPUTimingFake fake_timing_queries;
 
   decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
-      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));
+      base::BindRepeating(&gl::GPUTimingFake::GetFakeCPUTime));
 
   QueryManager::Query* query = CreateQuery(
       kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);
@@ -726,7 +726,7 @@ TEST_F(QueryManagerTest, TimeStampQueryPending) {
   gl::GPUTimingFake fake_timing_queries;
 
   decoder_->GetGLContext()->CreateGPUTimingClient()->SetCpuTimeForTesting(
-      base::Bind(&gl::GPUTimingFake::GetFakeCPUTime));
+      base::BindRepeating(&gl::GPUTimingFake::GetFakeCPUTime));
 
   QueryManager::Query* query = CreateQuery(
       kTarget, kClient1Id, shared_memory_id_, kSharedMemoryOffset, 0);

gpu/ipc/host/shader_disk_cache.cc

@@ -263,8 +263,8 @@ int ShaderDiskCacheEntry::WriteCallback(int rv) {
   op_type_ = WRITE_DATA;
   auto io_buf = base::MakeRefCounted<net::StringIOBuffer>(shader_);
   return entry_->WriteData(1, 0, io_buf.get(), shader_.length(),
-                           base::Bind(&ShaderDiskCacheEntry::OnOpComplete,
+                           base::BindOnce(&ShaderDiskCacheEntry::OnOpComplete,
-                                      weak_ptr_factory_.GetWeakPtr()),
+                                          weak_ptr_factory_.GetWeakPtr()),
                            false);
 }
 
@@ -357,8 +357,8 @@ int ShaderDiskReadHelper::OpenNextEntryComplete(int rv) {
   op_type_ = READ_COMPLETE;
   buf_ = base::MakeRefCounted<net::IOBufferWithSize>(entry_->GetDataSize(1));
   return entry_->ReadData(1, 0, buf_.get(), buf_->size(),
-                          base::Bind(&ShaderDiskReadHelper::OnOpComplete,
+                          base::BindOnce(&ShaderDiskReadHelper::OnOpComplete,
-                                     weak_ptr_factory_.GetWeakPtr()));
+                                         weak_ptr_factory_.GetWeakPtr()));
 }
 
 int ShaderDiskReadHelper::ReadComplete(int rv) {
@@ -416,14 +416,15 @@ void ShaderClearHelper::DoClearShaderCache(int rv) {
     switch (op_type_) {
       case VERIFY_CACHE_SETUP:
         rv = cache_->SetAvailableCallback(
-            base::Bind(&ShaderClearHelper::DoClearShaderCache,
+            base::BindRepeating(&ShaderClearHelper::DoClearShaderCache,
-                       weak_ptr_factory_.GetWeakPtr()));
+                                weak_ptr_factory_.GetWeakPtr()));
         op_type_ = DELETE_CACHE;
         break;
       case DELETE_CACHE:
-        rv = cache_->Clear(delete_begin_, delete_end_,
+        rv = cache_->Clear(
-                           base::Bind(&ShaderClearHelper::DoClearShaderCache,
+            delete_begin_, delete_end_,
-                                      weak_ptr_factory_.GetWeakPtr()));
+            base::BindRepeating(&ShaderClearHelper::DoClearShaderCache,
+                                weak_ptr_factory_.GetWeakPtr()));
         op_type_ = TERMINATE;
         break;
       case TERMINATE:
@@ -575,7 +576,7 @@ void ShaderDiskCache::Init() {
   int rv = disk_cache::CreateCacheBackend(
       net::SHADER_CACHE, net::CACHE_BACKEND_DEFAULT,
       cache_path_.Append(kGpuCachePath), CacheSizeBytes(), true, nullptr,
-      &backend_, base::Bind(&ShaderDiskCache::CacheCreatedCallback, this));
+      &backend_, base::BindOnce(&ShaderDiskCache::CacheCreatedCallback, this));
 
   if (rv == net::OK)
     cache_available_ = true;

services/ws/public/cpp/gpu/client_gpu_memory_buffer_manager.cc

@@ -4,6 +4,8 @@
 
 #include "services/ws/public/cpp/gpu/client_gpu_memory_buffer_manager.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ -17,21 +19,15 @@
 #include "services/ws/public/mojom/constants.mojom.h"
 #include "ui/gfx/buffer_format_util.h"
 
-using DestructionCallback = base::Callback<void(const gpu::SyncToken& sync)>;
-
-namespace gpu {
-class GpuMemoryBufferSupport;
-}
-
 namespace ws {
-
 namespace {
 
 void NotifyDestructionOnCorrectThread(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    const DestructionCallback& callback,
+    gpu::GpuMemoryBufferImpl::DestructionCallback callback,
     const gpu::SyncToken& sync_token) {
-  task_runner->PostTask(FROM_HERE, base::Bind(callback, sync_token));
+  task_runner->PostTask(FROM_HERE,
+                        base::BindOnce(std::move(callback), sync_token));
 }
 
 }  // namespace
@@ -46,15 +42,14 @@ ClientGpuMemoryBufferManager::ClientGpuMemoryBufferManager(
   // The thread is owned by this object. Which means the task will not run if
   // the object has been destroyed. So Unretained() is safe.
   thread_.task_runner()->PostTask(
-      FROM_HERE,
+      FROM_HERE, base::BindOnce(&ClientGpuMemoryBufferManager::InitThread,
-      base::Bind(&ClientGpuMemoryBufferManager::InitThread,
+                                base::Unretained(this), gpu.PassInterface()));
-                 base::Unretained(this), base::Passed(gpu.PassInterface())));
 }
 
 ClientGpuMemoryBufferManager::~ClientGpuMemoryBufferManager() {
   thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&ClientGpuMemoryBufferManager::TearDownThread,
+      FROM_HERE, base::BindOnce(&ClientGpuMemoryBufferManager::TearDownThread,
-                            base::Unretained(this)));
+                                base::Unretained(this)));
   thread_.Stop();
 }
 
@@ -62,8 +57,8 @@ void ClientGpuMemoryBufferManager::InitThread(
     mojom::GpuMemoryBufferFactoryPtrInfo gpu_info) {
   gpu_.Bind(std::move(gpu_info));
   gpu_.set_connection_error_handler(
-      base::Bind(&ClientGpuMemoryBufferManager::DisconnectGpuOnThread,
+      base::BindOnce(&ClientGpuMemoryBufferManager::DisconnectGpuOnThread,
-                 base::Unretained(this)));
+                     base::Unretained(this)));
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
 }
 
@@ -102,7 +97,7 @@ void ClientGpuMemoryBufferManager::AllocateGpuMemoryBufferOnThread(
   pending_allocation_waiters_.insert(wait);
   gpu_->CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId(++counter_), size, format, usage,
-      base::Bind(
+      base::BindOnce(
           &ClientGpuMemoryBufferManager::OnGpuMemoryBufferAllocatedOnThread,
           base::Unretained(this), handle, wait));
 }
@@ -125,8 +120,8 @@ void ClientGpuMemoryBufferManager::DeletedGpuMemoryBuffer(
   if (!thread_.task_runner()->BelongsToCurrentThread()) {
     thread_.task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&ClientGpuMemoryBufferManager::DeletedGpuMemoryBuffer,
+        base::BindOnce(&ClientGpuMemoryBufferManager::DeletedGpuMemoryBuffer,
-                   base::Unretained(this), id, sync_token));
+                       base::Unretained(this), id, sync_token));
     return;
   }
 
@@ -149,22 +144,22 @@ ClientGpuMemoryBufferManager::CreateGpuMemoryBuffer(
                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   thread_.task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ClientGpuMemoryBufferManager::AllocateGpuMemoryBufferOnThread,
+      base::BindOnce(
-                 base::Unretained(this), size, format, usage, &gmb_handle,
+          &ClientGpuMemoryBufferManager::AllocateGpuMemoryBufferOnThread,
-                 &wait));
+          base::Unretained(this), size, format, usage, &gmb_handle, &wait));
   wait.Wait();
   if (gmb_handle.is_null())
     return nullptr;
 
   auto gmb_handle_id = gmb_handle.id;
-  DestructionCallback callback =
+  auto callback =
-      base::Bind(&ClientGpuMemoryBufferManager::DeletedGpuMemoryBuffer,
+      base::BindOnce(&ClientGpuMemoryBufferManager::DeletedGpuMemoryBuffer,
-                 weak_ptr_, gmb_handle_id);
+                     weak_ptr_, gmb_handle_id);
-  std::unique_ptr<gpu::GpuMemoryBufferImpl> buffer(
+  std::unique_ptr<gpu::GpuMemoryBufferImpl> buffer =
       gpu_memory_buffer_support_->CreateGpuMemoryBufferImplFromHandle(
           std::move(gmb_handle), size, format, usage,
-          base::Bind(&NotifyDestructionOnCorrectThread, thread_.task_runner(),
+          base::BindOnce(&NotifyDestructionOnCorrectThread,
-                     callback)));
+                         thread_.task_runner(), std::move(callback)));
   if (!buffer) {
     DeletedGpuMemoryBuffer(gmb_handle_id, gpu::SyncToken());
     return nullptr;

ui/gl/android/surface_texture.cc

@@ -5,6 +5,7 @@
 #include "ui/gl/android/surface_texture.h"
 
 #include <android/native_window_jni.h>
+#include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/logging.h"
@@ -31,19 +32,22 @@ SurfaceTexture::~SurfaceTexture() {
   Java_SurfaceTexturePlatformWrapper_destroy(env, j_surface_texture_);
 }
 
-void SurfaceTexture::SetFrameAvailableCallback(const base::Closure& callback) {
+void SurfaceTexture::SetFrameAvailableCallback(
+    base::RepeatingClosure callback) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_SurfaceTexturePlatformWrapper_setFrameAvailableCallback(
       env, j_surface_texture_,
-      reinterpret_cast<intptr_t>(new SurfaceTextureListener(callback, false)));
+      reinterpret_cast<intptr_t>(
+          new SurfaceTextureListener(std::move(callback), false)));
 }
 
 void SurfaceTexture::SetFrameAvailableCallbackOnAnyThread(
-    const base::Closure& callback) {
+    base::RepeatingClosure callback) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_SurfaceTexturePlatformWrapper_setFrameAvailableCallback(
       env, j_surface_texture_,
-      reinterpret_cast<intptr_t>(new SurfaceTextureListener(callback, true)));
+      reinterpret_cast<intptr_t>(
+          new SurfaceTextureListener(std::move(callback), true)));
 }
 
 void SurfaceTexture::UpdateTexImage() {

ui/gl/android/surface_texture.h

@@ -29,13 +29,13 @@ class GL_EXPORT SurfaceTexture
   // Note: Since callbacks come in from Java objects that might outlive objects
   // being referenced from the callback, the only robust way here is to create
   // the callback from a weak pointer to your object.
-  void SetFrameAvailableCallback(const base::Closure& callback);
+  void SetFrameAvailableCallback(base::RepeatingClosure callback);
 
   // Set the listener callback, but allow it to be invoked on any thread.  The
   // same caveats apply as SetFrameAvailableCallback, plus whatever other issues
   // show up due to multithreading (e.g., don't bind the Closure to a method
   // via a weak ref).
-  void SetFrameAvailableCallbackOnAnyThread(const base::Closure& callback);
+  void SetFrameAvailableCallbackOnAnyThread(base::RepeatingClosure callback);
 
   // Update the texture image to the most recent frame from the image stream.
   void UpdateTexImage();

ui/gl/android/surface_texture_listener.cc

@@ -4,6 +4,8 @@
 
 #include "ui/gl/android/surface_texture_listener.h"
 
+#include <utility>
+
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -13,9 +15,9 @@ using base::android::JavaParamRef;
 
 namespace gl {
 
-SurfaceTextureListener::SurfaceTextureListener(const base::Closure& callback,
+SurfaceTextureListener::SurfaceTextureListener(base::RepeatingClosure callback,
                                                bool use_any_thread)
-    : callback_(callback),
+    : callback_(std::move(callback)),
       browser_loop_(base::ThreadTaskRunnerHandle::Get()),
       use_any_thread_(use_any_thread) {}
 

ui/gl/android/surface_texture_listener.h

@@ -38,12 +38,12 @@ class GL_EXPORT SurfaceTextureListener {
   // If use_any_thread is true, then the FrameAvailable callback will happen
   // on whatever thread calls us.  Otherwise, we will call it back on the same
   // thread that was used to construct us.
-  SurfaceTextureListener(const base::Closure& callback, bool use_any_thread);
+  SurfaceTextureListener(base::RepeatingClosure callback, bool use_any_thread);
   ~SurfaceTextureListener();
 
   friend class SurfaceTexture;
 
-  base::Closure callback_;
+  base::RepeatingClosure callback_;
 
   scoped_refptr<base::SingleThreadTaskRunner> browser_loop_;
 

ui/gl/gl_context_cgl.cc

@@ -159,7 +159,8 @@ void GLContextCGL::Destroy() {
       // Delay releasing the pixel format for 10 seconds to reduce the number of
       // unnecessary GPU switches.
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-          FROM_HERE, base::Bind(&CGLReleasePixelFormat, discrete_pixelformat_),
+          FROM_HERE,
+          base::BindOnce(&CGLReleasePixelFormat, discrete_pixelformat_),
           base::TimeDelta::FromSeconds(10));
     } else {
       CGLReleasePixelFormat(discrete_pixelformat_);

ui/gl/gpu_timing.cc

@@ -4,6 +4,8 @@
 
 #include "ui/gl/gpu_timing.h"
 
+#include <utility>
+
 #include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ -30,7 +32,7 @@ int32_t QueryTimestampBits() {
 
 class GPUTimingImpl : public GPUTiming {
  public:
-   GPUTimingImpl(GLContextReal* context);
+  explicit GPUTimingImpl(GLContextReal* context);
   ~GPUTimingImpl() override;
 
   void ForceTimeElapsedQuery() { force_time_elapsed_query_ = true; }
@@ -51,8 +53,8 @@ class GPUTimingImpl : public GPUTiming {
            ? (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds()
            : cpu_time_for_testing_.Run();
   }
-  void SetCpuTimeForTesting(const base::Callback<int64_t(void)>& cpu_time) {
+  void SetCpuTimeForTesting(base::RepeatingCallback<int64_t(void)> cpu_time) {
-    cpu_time_for_testing_ = cpu_time;
+    cpu_time_for_testing_ = std::move(cpu_time);
   }
 
   void UpdateQueryResults();
@@ -75,7 +77,7 @@ class GPUTimingImpl : public GPUTiming {
  private:
   scoped_refptr<GPUTimingClient> CreateGPUTimingClient() override;
 
-  base::Callback<int64_t(void)> cpu_time_for_testing_;
+  base::RepeatingCallback<int64_t(void)> cpu_time_for_testing_;
   GPUTiming::TimerType timer_type_ = GPUTiming::kTimerTypeInvalid;
   uint32_t disjoint_counter_ = 0;
   int64_t offset_ = 0;  // offset cache when timer_type_ == kTimerTypeARB
@@ -84,7 +86,7 @@ class GPUTimingImpl : public GPUTiming {
   int32_t timestamp_bit_count_gl_ = -1;  // gl implementation timestamp bits
 
   uint32_t next_timer_query_id_ = 0;
-  uint32_t next_good_timer_query_id_ = 0; // identify bad ids for disjoints.
+  uint32_t next_good_timer_query_id_ = 0;  // identify bad ids for disjoints.
   uint32_t query_disjoint_count_ = 0;
 
   // Extra state tracking data for elapsed timer queries.
@@ -122,7 +124,7 @@ class QueryResult : public base::RefCounted<QueryResult> {
 
 class TimerQuery : public base::RefCounted<TimerQuery> {
  public:
-  TimerQuery(uint32_t next_id);
+  explicit TimerQuery(uint32_t next_id);
   virtual void Destroy() = 0;
 
   // Returns true when UpdateQueryResults() is ready to be called.
@@ -135,7 +137,7 @@ class TimerQuery : public base::RefCounted<TimerQuery> {
   virtual void PrepareNextUpdate(scoped_refptr<TimerQuery> prev) {}
 
   uint32_t timer_query_id_ = 0;
-  int64_t time_stamp_ = 0; // Timestamp of the query, could be estimated.
+  int64_t time_stamp_ = 0;  // Timestamp of the query, could be estimated.
 
  protected:
   friend class base::RefCounted<TimerQuery>;
@@ -271,8 +273,7 @@ class TimeElapsedTimerQuery : public TimerQuery {
 
 class TimeStampTimerQuery : public TimerQuery {
  public:
-  TimeStampTimerQuery(uint32_t next_id)
+  explicit TimeStampTimerQuery(uint32_t next_id) : TimerQuery(next_id) {
-      : TimerQuery(next_id) {
     glGenQueries(1, &gl_query_id_);
   }
 
@@ -649,9 +650,9 @@ int64_t GPUTimingClient::GetCurrentCPUTime() {
 }
 
 void GPUTimingClient::SetCpuTimeForTesting(
-    const base::Callback<int64_t(void)>& cpu_time) {
+    base::RepeatingCallback<int64_t(void)> cpu_time) {
   DCHECK(gpu_timing_);
-  gpu_timing_->SetCpuTimeForTesting(cpu_time);
+  gpu_timing_->SetCpuTimeForTesting(std::move(cpu_time));
 }
 
 bool GPUTimingClient::IsForceTimeElapsedQuery() {

ui/gl/gpu_timing.h

@@ -141,7 +141,7 @@ class GL_EXPORT GPUTimingClient
   bool CheckAndResetTimerErrors();
 
   int64_t GetCurrentCPUTime();
-  void SetCpuTimeForTesting(const base::Callback<int64_t(void)>& cpu_time);
+  void SetCpuTimeForTesting(base::RepeatingCallback<int64_t(void)> cpu_time);
 
   bool IsForceTimeElapsedQuery();
   void ForceTimeElapsedQuery();

ui/gl/gpu_timing_unittest.cc

@@ -71,7 +71,8 @@ class GPUTimingTest : public testing::Test {
 
     scoped_refptr<GPUTimingClient> client = context_->CreateGPUTimingClient();
     if (!cpu_time_bounded_) {
-      client->SetCpuTimeForTesting(base::Bind(&GPUTimingFake::GetFakeCPUTime));
+      client->SetCpuTimeForTesting(
+          base::BindRepeating(&GPUTimingFake::GetFakeCPUTime));
       cpu_time_bounded_ = true;
     }
     return client;
@@ -93,7 +94,7 @@ TEST_F(GPUTimingTest, FakeTimerTest) {
   gpu_timing_fake_queries_.SetCurrentCPUTime(123);
   EXPECT_EQ(123, gpu_timing_client->GetCurrentCPUTime());
 
-  base::Callback<int64_t(void)> empty;
+  base::RepeatingCallback<int64_t(void)> empty;
   gpu_timing_client->SetCpuTimeForTesting(empty);
   EXPECT_NE(123, gpu_timing_client->GetCurrentCPUTime());
 }