Move gpu memory calculations to Compositor.

content/common/gpu/gpu_memory_manager.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 "content/common/gpu/gpu_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 41 matching lines @@
 
 GpuMemoryManager::~GpuMemoryManager() {
   DCHECK(tracking_groups_.empty());
   DCHECK(clients_visible_mru_.empty());
   DCHECK(clients_nonvisible_mru_.empty());
   DCHECK(clients_nonsurface_.empty());
   DCHECK(!bytes_allocated_managed_current_);
   DCHECK(!bytes_allocated_unmanaged_current_);
 }
 
-void GpuMemoryManager::UpdateAvailableGpuMemory() {
-  // If the value was overridden on the command line, use the specified value.
-  static bool client_hard_limit_bytes_overridden =
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kForceGpuMemAvailableMb);
-  if (client_hard_limit_bytes_overridden) {
-    base::StringToUint64(
-        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-            switches::kForceGpuMemAvailableMb),
-        &client_hard_limit_bytes_);
-    client_hard_limit_bytes_ *= 1024 * 1024;
-    return;
-  }
-
-#if defined(OS_ANDROID)
-  // On non-Android, we use an operating system query when possible.
-  // We do not have a reliable concept of multiple GPUs existing in
-  // a system, so just be safe and go with the minimum encountered.
-  uint64 bytes_min = 0;
-
-  // Only use the clients that are visible, because otherwise the set of clients
-  // we are querying could become extremely large.
-  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
-      it != clients_visible_mru_.end();
-      ++it) {
-    const GpuMemoryManagerClientState* client_state = *it;
-    if (!client_state->has_surface_)
-      continue;
-    if (!client_state->visible_)
-      continue;
-
-    uint64 bytes = 0;
-    if (client_state->client_->GetTotalGpuMemory(&bytes)) {
-      if (!bytes_min || bytes < bytes_min)
-        bytes_min = bytes;
-    }
-  }
-
-  client_hard_limit_bytes_ = bytes_min;
-  // Clamp the observed value to a specific range on Android.
-  client_hard_limit_bytes_ = std::max(client_hard_limit_bytes_,
-                                      static_cast<uint64>(8 * 1024 * 1024));
-  client_hard_limit_bytes_ = std::min(client_hard_limit_bytes_,
-                                      static_cast<uint64>(256 * 1024 * 1024));
-#else
-  // Ignore what the system said and give all clients the same maximum
-  // allocation on desktop platforms.
-  client_hard_limit_bytes_ = 512 * 1024 * 1024;
-#endif
-}
-
 void GpuMemoryManager::ScheduleManage(
     ScheduleManageTime schedule_manage_time) {
   if (disable_schedule_manage_)
     return;
   if (manage_immediate_scheduled_)
     return;
   if (schedule_manage_time == kScheduleManageNow) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&GpuMemoryManager::Manage, AsWeakPtr()));
     manage_immediate_scheduled_ = true;
@@ skipping 121 matching lines @@
 
   video_memory_usage_stats->bytes_allocated = GetCurrentUsage();
   video_memory_usage_stats->bytes_allocated_historical_max =
       bytes_allocated_historical_max_;
 }
 
 void GpuMemoryManager::Manage() {
   manage_immediate_scheduled_ = false;
   delayed_manage_callback_.Cancel();
 
-  // Update the amount of GPU memory available on the system.
-  UpdateAvailableGpuMemory();
-
   // Determine which clients are "hibernated" (which determines the
   // distribution of frontbuffers and memory among clients that don't have
   // surfaces).
   SetClientsHibernatedState();
 
-  // Assign memory allocations to clients that have surfaces.
-  AssignSurfacesAllocations();
-
-  // Assign memory allocations to clients that don't have surfaces.
-  AssignNonSurfacesAllocations();
-
   SendUmaStatsToBrowser();
 }
 
-void GpuMemoryManager::AssignSurfacesAllocations() {
-  // Send that allocation to the clients.
-  ClientStateList clients = clients_visible_mru_;
-  clients.insert(clients.end(),
-                 clients_nonvisible_mru_.begin(),
-                 clients_nonvisible_mru_.end());
-  for (ClientStateList::const_iterator it = clients.begin();
-       it != clients.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-
-    // Populate and send the allocation to the client
-    MemoryAllocation allocation;
-    allocation.bytes_limit_when_visible = client_hard_limit_bytes_;
-#if defined(OS_ANDROID)
-    // On Android, because there is only one visible tab at any time, allow
-    // that renderer to cache as much as it can.
-    allocation.priority_cutoff_when_visible =
-        MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
-#else
-    // On desktop platforms, instruct the renderers to cache only a smaller
-    // set, to play nice with other renderers and other applications. If this
-    // if not done, then the system can become unstable.
-    // http://crbug.com/145600 (Linux)
-    // http://crbug.com/141377 (Mac)
-    allocation.priority_cutoff_when_visible =
-        MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
-#endif
-
-    client_state->client_->SetMemoryAllocation(allocation);
-    client_state->client_->SuggestHaveFrontBuffer(!client_state->hibernated_);
-  }
-}
-
-void GpuMemoryManager::AssignNonSurfacesAllocations() {
-  for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
-       it != clients_nonsurface_.end();
-       ++it) {
-    GpuMemoryManagerClientState* client_state = *it;
-    MemoryAllocation allocation;
-
-    if (!client_state->hibernated_) {
-      allocation.bytes_limit_when_visible = client_hard_limit_bytes_;
-      allocation.priority_cutoff_when_visible =
-          MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
-    }
-
-    client_state->client_->SetMemoryAllocation(allocation);
-  }
-}
-
 void GpuMemoryManager::SetClientsHibernatedState() const {
   // Re-set all tracking groups as being hibernated.
   for (TrackingGroupMap::const_iterator it = tracking_groups_.begin();
        it != tracking_groups_.end();
        ++it) {
     GpuMemoryTrackingGroup* tracking_group = it->second;
     tracking_group->hibernated_ = true;
   }
   // All clients with surfaces that are visible are non-hibernated.
   uint64 non_hibernated_clients = 0;
@@ skipping 65 matching lines @@
 
 void GpuMemoryManager::RemoveClientFromList(
     GpuMemoryManagerClientState* client_state) {
   DCHECK(client_state->list_iterator_valid_);
   ClientStateList* client_list = GetClientList(client_state);
   client_list->erase(client_state->list_iterator_);
   client_state->list_iterator_valid_ = false;
 }
 
 }  // namespace content