Move gpu memory calculations to Compositor.

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 243 matching lines @@
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current (not necessary for
   // RetireSyncPoint or WaitSyncPoint).
   if (decoder_.get() &&
       message.type() != GpuCommandBufferMsg_SetGetBuffer::ID &&
       message.type() != GpuCommandBufferMsg_WaitForTokenInRange::ID &&
       message.type() != GpuCommandBufferMsg_WaitForGetOffsetInRange::ID &&
       message.type() != GpuCommandBufferMsg_RegisterTransferBuffer::ID &&
       message.type() != GpuCommandBufferMsg_DestroyTransferBuffer::ID &&
       message.type() != GpuCommandBufferMsg_RetireSyncPoint::ID &&
-      message.type() != GpuCommandBufferMsg_SignalSyncPoint::ID &&
-      message.type() !=
-          GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback::ID) {
+      message.type() != GpuCommandBufferMsg_SignalSyncPoint::ID) {
     if (!MakeCurrent())
       return false;
     have_context = true;
   }
 
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
@@ skipping 17 matching lines @@
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoEncoder,
                                     OnCreateVideoEncoder)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetSurfaceVisible,
                         OnSetSurfaceVisible)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RetireSyncPoint,
                         OnRetireSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncPoint,
                         OnSignalSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
                         OnSignalQuery)
-    IPC_MESSAGE_HANDLER(
-        GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback,
-        OnSetClientHasMemoryAllocationChangedCallback)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
   if (have_context) {
@@ skipping 653 matching lines @@
                      this->AsWeakPtr(),
                      id));
         return;
       }
     }
   }
   // Something went wrong, run callback immediately.
   OnSignalSyncPointAck(id);
 }
 
-
-void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
-    bool has_callback) {
-  TRACE_EVENT0(
-      "gpu",
-      "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
-  if (has_callback) {
-    if (!memory_manager_client_state_) {
-      memory_manager_client_state_.reset(GetMemoryManager()->CreateClientState(
-          this, surface_id_ != 0, true));
-    }
-  } else {
-    memory_manager_client_state_.reset();
-  }
-}
-
 void GpuCommandBufferStub::OnCreateImage(int32 id,
                                          gfx::GpuMemoryBufferHandle handle,
                                          gfx::Size size,
                                          gfx::BufferFormat format,
                                          uint32 internalformat) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateImage");
 
   if (!decoder_)
     return;
 
@@ skipping 92 matching lines @@
 }
 
 const gpu::gles2::FeatureInfo* GpuCommandBufferStub::GetFeatureInfo() const {
   return context_group_->feature_info();
 }
 
 gpu::gles2::MemoryTracker* GpuCommandBufferStub::GetMemoryTracker() const {
   return context_group_->memory_tracker();
 }
 
-void GpuCommandBufferStub::SetMemoryAllocation(
-    const gpu::MemoryAllocation& allocation) {
-  if (!last_memory_allocation_valid_ ||
-      !allocation.Equals(last_memory_allocation_)) {
-    Send(new GpuCommandBufferMsg_SetMemoryAllocation(
-        route_id_, allocation));
-  }
-
-  last_memory_allocation_valid_ = true;
-  last_memory_allocation_ = allocation;
-}
-
 void GpuCommandBufferStub::SuggestHaveFrontBuffer(
     bool suggest_have_frontbuffer) {
   // This can be called outside of OnMessageReceived, so the context needs
   // to be made current before calling methods on the surface.
   if (surface_.get() && MakeCurrent())
     surface_->SetFrontbufferAllocation(suggest_have_frontbuffer);
 }
 
 bool GpuCommandBufferStub::CheckContextLost() {
   DCHECK(command_buffer_);
@@ skipping 50 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content