Cleanup GpuMemoryManager and helpers.

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 131 matching lines @@
   ~DevToolsChannelData() override {}
   scoped_ptr<base::Value> value_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsChannelData);
 };
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 DevToolsChannelData::CreateForChannel(GpuChannel* channel) {
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
-  res->SetDouble("limit_bytes",
-                 channel->gpu_channel_manager()
-                     ->gpu_memory_manager()
-                     ->GetMaximumClientAllocation());
   return new DevToolsChannelData(res.release());
 }
 
 void RunOnThread(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                  const base::Closure& callback) {
   if (task_runner->BelongsToCurrentThread()) {
     callback.Run();
   } else {
     task_runner->PostTask(FROM_HERE, callback);
   }
@@ skipping 36 matching lines @@
       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),
       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_(active_url) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
     DCHECK(context_group_->bind_generates_resource() ==
            attrib_parser.bind_generates_resource);
@@ skipping 380 matching lines @@
     LOG(ERROR) << "Failed to make context current.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (!context->GetGLStateRestorer()) {
     context->SetGLStateRestorer(
         new gpu::GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
-  if (!context->GetTotalGpuMemory(&total_gpu_memory_))
-    total_gpu_memory_ = 0;
-
   if (!context_group_->has_program_cache() &&
       !context_group_->feature_info()->workarounds().disable_program_cache) {
     context_group_->set_program_cache(
         channel_->gpu_channel_manager()->program_cache());
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
   if (!decoder_->Initialize(surface_, context, offscreen_, initial_size_,
                             disallowed_features_, requested_attribs_)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
@@ skipping 565 matching lines @@
 void GpuCommandBufferStub::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void GpuCommandBufferStub::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
-bool GpuCommandBufferStub::GetTotalGpuMemory(uint64* bytes) {
-  *bytes = total_gpu_memory_;
-  return !!total_gpu_memory_;
-}
-
-gfx::Size GpuCommandBufferStub::GetSurfaceSize() const {
-  if (!surface_.get())
-    return gfx::Size();
-  return surface_->GetSize();
-}
-
 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::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_);
   gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   bool was_lost = state.error == gpu::error::kLostContext;
 
   if (was_lost) {
     bool was_lost_by_robustness =
         decoder_ && decoder_->WasContextLostByRobustnessExtension();
 
     // Work around issues with recovery by allowing a new GPU process to launch.
@@ skipping 42 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content