Splitting GpuMemoryAllocation into two parts: for renderer and browser

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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 105 matching lines @@
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_DestroyTransferBuffer,
                                     OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetTransferBuffer,
                                     OnGetTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoDecoder,
                                     OnCreateVideoDecoder)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyVideoDecoder,
                         OnDestroyVideoDecoder)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetSurfaceVisible,
                         OnSetSurfaceVisible)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateBackbuffer,
+                        OnCreateBackbuffer)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyBackbuffer,
+                        OnDestroyBackbuffer)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   DCHECK(handled);
   return handled;
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
@@ skipping 420 matching lines @@
   decoder->Initialize(profile, reply_message,
                       channel_->renderer_process());
 }
 
 void GpuCommandBufferStub::OnDestroyVideoDecoder(int decoder_route_id) {
   channel_->RemoveRoute(decoder_route_id);
   video_decoders_.Remove(decoder_route_id);
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
-  if (visible)
-    surface_->SetBufferAllocation(
-        gfx::GLSurface::BUFFER_ALLOCATION_FRONT_AND_BACK);
   DCHECK(surface_state_.get());
   surface_state_->visible = visible;
   surface_state_->last_used_time = base::TimeTicks::Now();
   channel_->gpu_channel_manager()->gpu_memory_manager()->ScheduleManage();
 }
 
+void GpuCommandBufferStub::OnCreateBackbuffer() {
+  printf("   [%i - %p] %s\n", getpid(), this, __PRETTY_FUNCTION__);

[mmocny, 2012/03/15 19:11:43]

printfs will be removed..

+  DCHECK(surface_);
+  surface_->SetBufferAllocation(
+      gfx::GLSurface::BUFFER_ALLOCATION_FRONT_AND_BACK);

[mmocny, 2012/03/15 19:11:43]

I will decouple front/back buffer management, but for now I'm using the existing
code as is.

+}
+
+void GpuCommandBufferStub::OnDestroyBackbuffer() {
+  printf("   [%i - %p] %s\n", getpid(), this, __PRETTY_FUNCTION__);
+  DCHECK(surface_);
+  // TODO(mmocny): Decouple frontbuffer drop from backbuffer drop.
+  surface_->SetBufferAllocation(
+      (allocation_.suggest_have_frontbuffer) ?

[mmocny, 2012/03/15 19:11:43]

Ditto here for decoupling.  As is, we wait for renderer to request backbuffer
drop to initiate dropping frontbuffer. This will change.

+        gfx::GLSurface::BUFFER_ALLOCATION_FRONT_ONLY :
+        gfx::GLSurface::BUFFER_ALLOCATION_NONE);
+}
+
 void GpuCommandBufferStub::SendConsoleMessage(
     int32 id,
     const std::string& message) {
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
   IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
       route_id_, console_message);
   msg->set_unblock(true);
   Send(msg);
@@ skipping 30 matching lines @@
   Send(new GpuCommandBufferMsg_SetMemoryAllocation(route_id_, allocation));
 }
 
 void GpuCommandBufferStub::SetMemoryAllocation(
     const GpuMemoryAllocation& allocation) {
   if (allocation == allocation_)
     return;
   allocation_ = allocation;
 
   SendMemoryAllocationToProxy(allocation);
-
-  if (!surface_)
-    return;
-  if (allocation.has_frontbuffer && allocation.has_backbuffer)
-    surface_->SetBufferAllocation(
-        gfx::GLSurface::BUFFER_ALLOCATION_FRONT_AND_BACK);
-  else if (allocation.has_frontbuffer)
-    surface_->SetBufferAllocation(
-        gfx::GLSurface::BUFFER_ALLOCATION_FRONT_ONLY);
-  else
-    surface_->SetBufferAllocation(
-        gfx::GLSurface::BUFFER_ALLOCATION_NONE);
 }
 
 #endif  // defined(ENABLE_GPU)