Adding GpuMemoryManager to track GpuCommandBufferStub visibility and last_used_time and dictate mem…

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"
 #include "base/shared_memory.h"
+#include "base/time.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
+#include "content/common/gpu/gpu_memory_allocation.h"
+#include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_watchdog.h"
 #include "content/common/gpu/image_transport_surface.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_switches.h"
 
+GpuCommandBufferStub::SurfaceState::SurfaceState(int32 surface_id,
+                                              bool visible,

[nduca, 2012/02/01 00:01:17]

Awkward indent.

+                                              base::TimeTicks last_used_time)
+    : surface_id(surface_id),
+      visible(visible),
+      last_used_time(last_used_time) {
+}
+
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     GpuCommandBufferStub* share_group,
     gfx::PluginWindowHandle handle,
     const gfx::Size& size,
     const gpu::gles2::DisallowedFeatures& disallowed_features,
     const std::string& allowed_extensions,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     int32 route_id,
     int32 surface_id,
     GpuWatchdog* watchdog,
     bool software)
     : channel_(channel),
       handle_(handle),
       initial_size_(size),
       disallowed_features_(disallowed_features),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       route_id_(route_id),
       software_(software),
       last_flush_count_(0),
-      surface_id_(surface_id),
+      surface_state_(),

[nduca, 2012/02/01 00:01:17]

not needed since its an scoped_ptr.

+      affected_surface_ids_(),

[nduca, 2012/02/01 00:01:17]

not needed.

       parent_stub_for_initialization_(),
       parent_texture_for_initialization_(0),
       watchdog_(watchdog) {
   if (share_group) {
     context_group_ = share_group->context_group_;
   } else {
     // TODO(gman): this needs to be false for everything but Pepper.
     bool bind_generates_resource = true;
     context_group_ = new gpu::gles2::ContextGroup(bind_generates_resource);
   }
+  if (surface_id != 0)
+    surface_state_.reset(new GpuCommandBufferStubBase::SurfaceState(
+        surface_id, true, base::TimeTicks::Now()));
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-  gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(surface_id_));
+  gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(surface_id()));
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   // Ensure the appropriate GL context is current before handling any IPC
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current.
   if (decoder_.get()) {
     if (!decoder_->MakeCurrent()) {
       DLOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
@@ skipping 72 matching lines @@
 
   if (decoder_.get()) {
     decoder_->Destroy();
     decoder_.reset();
   }
 
   command_buffer_.reset();
 
   context_ = NULL;
   surface_ = NULL;
+
+  channel_->gpu_channel_manager()->gpu_memory_manager()->ScheduleManage();
 }
 
 void GpuCommandBufferStub::OnInitializeFailed(IPC::Message* reply_message) {
   Destroy();
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnInitialize(
     IPC::Message* reply_message) {
@@ skipping 101 matching lines @@
 
   if (parent_stub_for_initialization_) {
     decoder_->SetParent(parent_stub_for_initialization_->decoder_.get(),
                         parent_texture_for_initialization_);
     parent_stub_for_initialization_.reset();
     parent_texture_for_initialization_ = 0;
   }
 
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, true);
   Send(reply_message);
+
+  channel_->gpu_channel_manager()->gpu_memory_manager()->ScheduleManage();
 }
 
 void GpuCommandBufferStub::OnSetGetBuffer(
     int32 shm_id, IPC::Message* reply_message) {
   if (command_buffer_.get()) {
     command_buffer_->SetGetBuffer(shm_id);
   } else {
     DLOG(ERROR) << "no command_buffer.";
     reply_message->set_reply_error();
   }
@@ skipping 202 matching lines @@
                       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) {
   surface_->SetVisible(visible);
+  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::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);
 }
 
+GpuCommandBufferStubBase::SurfaceState* GpuCommandBufferStub::surface_state() {
+  return surface_state_.get();
+}
+
+const std::vector<int32>& GpuCommandBufferStub::affected_surface_ids() {
+  return affected_surface_ids_;
+}
+
+void GpuCommandBufferStub::SendMemoryAllocationToProxy(
+    const GpuMemoryAllocation& allocation) {
+  // TODO(mmocny): Send callback once gl extensions are added.
+}
+
 #endif  // defined(ENABLE_GPU)