Revert of 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 187 matching lines @@
       initial_size_(size),
       disallowed_features_(disallowed_features),
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(false),
       command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
       stream_id_(stream_id),
       route_id_(route_id),
       offscreen_(offscreen),
       last_flush_count_(0),
+      last_memory_allocation_valid_(false),
       watchdog_(watchdog),
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
       preemption_flag_(preempt_by_flag),
       active_url_(active_url),
       total_gpu_memory_(0) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
@@ skipping 52 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_SignalSyncPoint::ID &&
+      message.type() !=
+          GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback::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 18 matching lines @@
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetSurfaceVisible,
                         OnSetSurfaceVisible)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RetireSyncPoint,
                         OnRetireSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncPoint,
                         OnSignalSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken,
                         OnSignalSyncToken)
     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();
 
   // Ensure that any delayed work that was created will be handled.
@@ skipping 137 matching lines @@
   }
 
   if (initialized_) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     if (handle_.is_null() && !active_url_.is_empty()) {
       gpu_channel_manager->Send(
           new GpuHostMsg_DidDestroyOffscreenContext(active_url_));
     }
   }
 
+  memory_manager_client_state_.reset();
+
   while (!sync_points_.empty())
     OnRetireSyncPoint(sync_points_.front());
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
@@ skipping 424 matching lines @@
       new GpuVideoEncodeAccelerator(encoder_route_id, this);
   encoder->Initialize(input_format,
                       input_visible_size,
                       output_profile,
                       initial_bitrate,
                       reply_message);
   // encoder is registered as a DestructionObserver of this stub and will
   // self-delete during destruction of this stub.
 }
 
-// TODO(sohanjg): cleanup this and the client side too.
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetSurfaceVisible");
+  if (memory_manager_client_state_)
+    memory_manager_client_state_->SetVisible(visible);
 }
 
 void GpuCommandBufferStub::InsertSyncPoint(uint32 sync_point, bool retire) {
   sync_points_.push_back(sync_point);
   if (retire) {
     OnMessageReceived(
         GpuCommandBufferMsg_RetireSyncPoint(route_id_, sync_point));
   }
 }
 
@@ skipping 167 matching lines @@
     uint64_t release) {
   DCHECK(waiting_for_sync_point_);
   DCHECK(!scheduler_->scheduled());
   TRACE_EVENT_ASYNC_END1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
                          this);
   PullTextureUpdates(namespace_id, command_buffer_id, release);
   waiting_for_sync_point_ = false;
   scheduler_->SetScheduled(true);
 }
 
+
+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, !offscreen_, 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 85 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