Rename SurfaceState to MemoryManagerState

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 69 matching lines @@
 }
 
 // The first time polling a fence, delay some extra time to allow other
 // stubs to process some work, or else the timing of the fences could
 // allow a pattern of alternating fast and slow frames to occur.
 const int64 kHandleMoreWorkPeriodMs = 2;
 const int64 kHandleMoreWorkPeriodBusyMs = 1;
 
 }  // namespace
 
-GpuCommandBufferStub::SurfaceState::SurfaceState(int32 surface_id,
-                                                 bool visible,
-                                                 base::TimeTicks last_used_time)
-    : surface_id(surface_id),
+GpuCommandBufferStub::MemoryManagerState::MemoryManagerState(
+    bool has_surface,
+    bool visible,
+    base::TimeTicks last_used_time)
+    : has_surface(has_surface),
       visible(visible),
+      client_has_memory_allocation_changed_callback(false),
       last_used_time(last_used_time) {
 }
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     GpuCommandBufferStub* share_group,
     const gfx::GLSurfaceHandle& handle,
     gpu::gles2::MailboxManager* mailbox_manager,
     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,
     const GURL& active_url)
     : 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),
+      surface_id_(surface_id),
       software_(software),
-      client_has_memory_allocation_changed_callback_(false),
       last_flush_count_(0),
       parent_stub_for_initialization_(),
       parent_texture_for_initialization_(0),
       watchdog_(watchdog),
       sync_point_wait_count_(0),
       delayed_work_scheduled_(false),
       active_url_(active_url) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
   if (share_group) {
     context_group_ = share_group->context_group_;
   } else {
     context_group_ = new gpu::gles2::ContextGroup(
         mailbox_manager,
         new GpuCommandBufferMemoryTracker(channel),
         true);
   }
-  if (surface_id != 0)
-    surface_state_.reset(new GpuCommandBufferStubBase::SurfaceState(
-        surface_id, true, base::TimeTicks::Now()));
+  memory_manager_state_.reset(new GpuCommandBufferStubBase::MemoryManagerState(
+      surface_id != 0, true, base::TimeTicks::Now()));
   if (handle_.sync_point)
     OnWaitSyncPoint(handle_.sync_point);
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(surface_id()));
 }
@@ skipping 542 matching lines @@
 }
 
 void GpuCommandBufferStub::OnDestroyVideoDecoder(int decoder_route_id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyVideoDecoder");
   channel_->RemoveRoute(decoder_route_id);
   video_decoders_.Remove(decoder_route_id);
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetSurfaceVisible");
-  DCHECK(surface_state_.get());
-  surface_state_->visible = visible;
-  surface_state_->last_used_time = base::TimeTicks::Now();
-    channel_->gpu_channel_manager()->gpu_memory_manager()->
-        ScheduleManage(visible);
+  memory_manager_state_->visible = visible;
+  memory_manager_state_->last_used_time = base::TimeTicks::Now();
+  channel_->gpu_channel_manager()->gpu_memory_manager()->
+      ScheduleManage(visible);
 }
 
 void GpuCommandBufferStub::OnDiscardBackbuffer() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDiscardBackbuffer");
   if (!surface_)
     return;
   surface_->SetBackbufferAllocation(false);
 }
 
 void GpuCommandBufferStub::OnEnsureBackbuffer() {
@@ skipping 47 matching lines @@
 
 void GpuCommandBufferStub::OnSignalSyncPointAck(uint32 id) {
   Send(new GpuCommandBufferMsg_SignalSyncPointAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
     bool has_callback) {
   TRACE_EVENT0(
       "gpu",
       "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
-  client_has_memory_allocation_changed_callback_ = has_callback;
+  memory_manager_state_->client_has_memory_allocation_changed_callback =
+      has_callback;
   channel_->gpu_channel_manager()->gpu_memory_manager()->
       ScheduleManage(false);
 }
 
 void GpuCommandBufferStub::SendConsoleMessage(
     int32 id,
     const std::string& message) {
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
@@ skipping 31 matching lines @@
     return gfx::Size();
   return surface_->GetSize();
 }
 
 bool GpuCommandBufferStub::IsInSameContextShareGroup(
     const GpuCommandBufferStubBase& other) const {
   return context_group_ ==
       static_cast<const GpuCommandBufferStub&>(other).context_group_;
 }
 
-bool GpuCommandBufferStub::
-    client_has_memory_allocation_changed_callback() const {
-  return client_has_memory_allocation_changed_callback_;
+
+const GpuCommandBufferStubBase::MemoryManagerState&
+    GpuCommandBufferStub::memory_manager_state() const {
+  return *memory_manager_state_.get();
 }
-
-bool GpuCommandBufferStub::has_surface_state() const {
-  return surface_state_ != NULL;
-}
-
-const GpuCommandBufferStubBase::SurfaceState&
-    GpuCommandBufferStub::surface_state() const {
-  DCHECK(has_surface_state());
-  return *surface_state_.get();
-}
-
 void GpuCommandBufferStub::SetMemoryAllocation(
     const GpuMemoryAllocation& allocation) {
   Send(new GpuCommandBufferMsg_SetMemoryAllocation(route_id_, allocation));
   // This can be called outside of OnMessageReceived, so the context needs to be
   // made current before calling methods on the surface.
   if (!surface_ || !MakeCurrent())
     return;
   surface_->SetFrontbufferAllocation(allocation.suggest_have_frontbuffer);
 }
 
 #endif  // defined(ENABLE_GPU)