Sync compositor: Ignore command buffer memory callback

content/common/gpu/client/context_provider_command_buffer.cc

 // Copyright (c) 2013 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 "content/common/gpu/client/context_provider_command_buffer.h"
 
 #include <set>
 #include <vector>
 
 #include "base/callback_helpers.h"
@@ skipping 25 matching lines @@
   ContextProviderCommandBuffer* provider_;
 };
 
 scoped_refptr<ContextProviderCommandBuffer>
 ContextProviderCommandBuffer::Create(
     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context3d,
     CommandBufferContextType type) {
   if (!context3d)
     return NULL;
 
-  return new ContextProviderCommandBuffer(context3d.Pass(), type);
+  const bool enable_memory_allocation_callback = true;
+  return new ContextProviderCommandBuffer(context3d.Pass(), type,
+                                          enable_memory_allocation_callback);
 }
 
 ContextProviderCommandBuffer::ContextProviderCommandBuffer(
     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context3d,
-    CommandBufferContextType type)
+    CommandBufferContextType type,
+    bool enable_memory_allocation_callback)
     : context3d_(context3d.Pass()),
       context_type_(type),
       debug_name_(CommandBufferContextTypeToString(type)),
+      enable_memory_allocation_callback_(enable_memory_allocation_callback),
       destroyed_(false) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(context3d_);
   context_thread_checker_.DetachFromThread();
 }
 
 ContextProviderCommandBuffer::~ContextProviderCommandBuffer() {
   DCHECK(main_thread_checker_.CalledOnValidThread() ||
          context_thread_checker_.CalledOnValidThread());
 
@@ skipping 33 matching lines @@
   if (!context3d_->InitializeOnCurrentThread())
     return false;
 
   InitializeCapabilities();
 
   std::string unique_context_name =
       base::StringPrintf("%s-%p", debug_name_.c_str(), context3d_.get());
   context3d_->traceBeginCHROMIUM("gpu_toplevel", unique_context_name.c_str());
 
   lost_context_callback_proxy_.reset(new LostContextCallbackProxy(this));
-  context3d_->GetCommandBufferProxy()->SetMemoryAllocationChangedCallback(
-      base::Bind(&ContextProviderCommandBuffer::OnMemoryAllocationChanged,
-                 base::Unretained(this)));
+
+  if (enable_memory_allocation_callback_) {
+    context3d_->GetCommandBufferProxy()->SetMemoryAllocationChangedCallback(

[no sievers, 2015/08/05 22:50:32]

Wait, can you just move this code to SetMemoryPolicyChangedCallback() and then
override that in your subclass to do nothing? :)

[boliu, 2015/08/06 01:30:33]

Totally thought about that!

But... enabling callbacks is not a synchronous operation. So doing it later
could affect when the first memory allocation callback happens, which could
intern affect when first raster starts, which can affect timings of a lot of
things.

So decided to not do that :)

[boliu, 2015/08/06 01:41:37]

And then I realize these two things actually happen at the exact same time. So
overriding this it is!

+        base::Bind(&ContextProviderCommandBuffer::OnMemoryAllocationChanged,
+                   base::Unretained(this)));
+  }
   return true;
 }
 
 void ContextProviderCommandBuffer::DetachFromThread() {
   context_thread_checker_.DetachFromThread();
 }
 
 gpu::gles2::GLES2Interface* ContextProviderCommandBuffer::ContextGL() {
   DCHECK(context3d_);
   DCHECK(lost_context_callback_proxy_);  // Is bound to thread.
@@ skipping 116 matching lines @@
 
 void ContextProviderCommandBuffer::SetMemoryPolicyChangedCallback(
     const MemoryPolicyChangedCallback& memory_policy_changed_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(memory_policy_changed_callback_.is_null() ||
          memory_policy_changed_callback.is_null());
   memory_policy_changed_callback_ = memory_policy_changed_callback;
 }
 
 }  // namespace content