ui: Prefer +/- operators to apply offsets.

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"
 
 #if defined(ENABLE_GPU)
 
 #include <algorithm>
 
@@ skipping 20 matching lines @@
 
 }
 
 GpuMemoryManager::GpuMemoryManager(
     size_t max_surfaces_with_frontbuffer_soft_limit)
     : manage_immediate_scheduled_(false),
       max_surfaces_with_frontbuffer_soft_limit_(
           max_surfaces_with_frontbuffer_soft_limit),
       bytes_available_gpu_memory_(0),
       bytes_available_gpu_memory_overridden_(false),
+      bytes_backgrounded_available_gpu_memory_(0),
       bytes_allocated_current_(0),
       bytes_allocated_managed_visible_(0),
       bytes_allocated_managed_backgrounded_(0),
       window_count_has_been_received_(false),
       window_count_(0),
       disable_schedule_manage_(false)
 {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kForceGpuMemAvailableMb)) {
     base::StringToSizeT(
       command_line->GetSwitchValueASCII(switches::kForceGpuMemAvailableMb),
       &bytes_available_gpu_memory_);
     bytes_available_gpu_memory_ *= 1024 * 1024;
     bytes_available_gpu_memory_overridden_ = true;
   } else
     bytes_available_gpu_memory_ = GetDefaultAvailableGpuMemory();
+  UpdateBackgroundedAvailableGpuMemory();
 }
 
 GpuMemoryManager::~GpuMemoryManager() {
   DCHECK(tracking_groups_.empty());
   DCHECK(clients_.empty());
   DCHECK(!bytes_allocated_current_);
   DCHECK(!bytes_allocated_managed_visible_);
   DCHECK(!bytes_allocated_managed_backgrounded_);
 }
 
 size_t GpuMemoryManager::GetAvailableGpuMemory() const {
   return bytes_available_gpu_memory_;
 }
 
+size_t GpuMemoryManager::GetCurrentBackgroundedAvailableGpuMemory() const {
+  if (bytes_allocated_managed_visible_ < GetAvailableGpuMemory()) {
+    return std::min(bytes_backgrounded_available_gpu_memory_,
+                    GetAvailableGpuMemory() - bytes_allocated_managed_visible_);
+  }
+  return 0;
+}
+
 size_t GpuMemoryManager::GetDefaultAvailableGpuMemory() const {
 #if defined(OS_ANDROID)
   return 32 * 1024 * 1024;
 #elif defined(OS_CHROMEOS)
   return 1024 * 1024 * 1024;
 #else
   return 256 * 1024 * 1024;
 #endif
 }
 
@@ skipping 102 matching lines @@
   bytes_available_gpu_memory_ = CalcAvailableFromGpuTotal(bytes_min);
 #endif
 
   // Never go below the default allocation
   bytes_available_gpu_memory_ = std::max(bytes_available_gpu_memory_,
                                          GetDefaultAvailableGpuMemory());
 
   // Never go above the maximum.
   bytes_available_gpu_memory_ = std::min(bytes_available_gpu_memory_,
                                          GetMaximumTotalGpuMemory());
+
+  // Update the backgrounded available gpu memory because it depends on
+  // the available GPU memory.
+  UpdateBackgroundedAvailableGpuMemory();
+}
+
+void GpuMemoryManager::UpdateBackgroundedAvailableGpuMemory() {
+  // Be conservative and disable saving backgrounded tabs' textures on Android
+  // for the moment
+#if defined(OS_ANDROID)
+  bytes_backgrounded_available_gpu_memory_ = 0;
+#else
+  bytes_backgrounded_available_gpu_memory_ = bytes_available_gpu_memory_ / 4;
+#endif
 }
 
 bool GpuMemoryManager::ClientsComparator::operator()(
     ClientState* lhs,
     ClientState* rhs) {
   if (lhs->has_surface != rhs->has_surface)
     return lhs->has_surface > rhs->has_surface;
   if (lhs->visible != rhs->visible)
     return lhs->visible > rhs->visible;
   if (lhs->last_used_time != rhs->last_used_time)
@@ skipping 68 matching lines @@
 void GpuMemoryManager::SetClientVisible(GpuMemoryManagerClient* client,
                                         bool visible)
 {
   ClientMap::const_iterator it = clients_.find(client);
   if (it == clients_.end())
     return;
   ClientState* client_state = it->second;
   if (client_state->visible == visible)
     return;
   client_state->visible = visible;
+  client_state->last_used_time = base::TimeTicks::Now();
   TrackValueChanged(client_state->managed_memory_stats.bytes_allocated, 0,
                     client_state->visible ?
                         &bytes_allocated_managed_backgrounded_ :
                         &bytes_allocated_managed_visible_);
   TrackValueChanged(0, client_state->managed_memory_stats.bytes_allocated,
                     client_state->visible ?
                         &bytes_allocated_managed_visible_ :
                         &bytes_allocated_managed_backgrounded_);
   ScheduleManage(visible);
 }
 
 void GpuMemoryManager::SetClientManagedMemoryStats(
     GpuMemoryManagerClient* client,
     const GpuManagedMemoryStats& stats)
 {
   ClientMap::const_iterator it = clients_.find(client);
   if (it == clients_.end())
     return;
   ClientState* client_state = it->second;
   TrackValueChanged(client_state->managed_memory_stats.bytes_allocated,
                     stats.bytes_allocated,
                     client_state->visible ?
                         &bytes_allocated_managed_visible_ :
                         &bytes_allocated_managed_backgrounded_);
   client_state->managed_memory_stats = stats;
+
+  // If this allocation pushed our usage of backgrounded tabs memory over the
+  // limit, then schedule a drop of backgrounded memory.
+  if (bytes_allocated_managed_backgrounded_ >
+      GetCurrentBackgroundedAvailableGpuMemory())
+    ScheduleManage(false);
 }
 
 void GpuMemoryManager::TestingSetClientVisible(
     GpuMemoryManagerClient* client, bool visible) {
   DCHECK(clients_.count(client));
   clients_[client]->visible = visible;
 }
 
 void GpuMemoryManager::TestingSetClientLastUsedTime(
     GpuMemoryManagerClient* client, base::TimeTicks last_used_time) {
@@ skipping 99 matching lines @@
   DCHECK(std::unique(clients.begin(), clients.end()) == clients.end());
 
   // Update the amount of GPU memory available on the system.
   UpdateAvailableGpuMemory(clients);
 
   // Determine which clients are "hibernated" (which determines the
   // distribution of frontbuffers and memory among clients that don't have
   // surfaces).
   SetClientsHibernatedState(clients);
 
-  // Determine how much memory to assign to give to visible clients
+  // Determine how much memory to assign to give to visible and backgrounded
+  // clients.
   size_t bytes_limit_when_visible = GetVisibleClientAllocation(clients);
 
   // Now give out allocations to everyone.
+  size_t bytes_allocated_backgrounded = 0;
   for (ClientStateVector::iterator it = clients.begin();
        it != clients.end();
        ++it) {
     ClientState* client_state = *it;
-
     GpuMemoryAllocation allocation;
     if (client_state->has_surface) {
       allocation.browser_allocation.suggest_have_frontbuffer =
           !client_state->hibernated;
+
+      // Set the state when visible.
       allocation.renderer_allocation.bytes_limit_when_visible =
           bytes_limit_when_visible;
       allocation.renderer_allocation.priority_cutoff_when_visible =
           GpuMemoryAllocationForRenderer::kPriorityCutoffAllowEverything;
-      allocation.renderer_allocation.bytes_limit_when_not_visible =
-          0;
-      allocation.renderer_allocation.priority_cutoff_when_not_visible =
-          GpuMemoryAllocationForRenderer::kPriorityCutoffAllowNothing;
+
+      // Set the state when backgrounded.
+      bool allow_allocation_when_backgrounded = false;
+      if (client_state->visible) {
+        // If the client is visible, then allow it to keep its textures, should
+        // it be backgrounded, but only if all textures required to draw will
+        // fit in total backgrounded memory limit.
+        allow_allocation_when_backgrounded =
+            client_state->managed_memory_stats.bytes_required <
+            bytes_backgrounded_available_gpu_memory_;
+      } else {
+        // If the client is backgrounded, then allow it to keep its textures
+        // if everything required to draw fits in-budget.
+        allow_allocation_when_backgrounded =
+            client_state->managed_memory_stats.bytes_required +
+            bytes_allocated_backgrounded <
+            GetCurrentBackgroundedAvailableGpuMemory();
+        if (allow_allocation_when_backgrounded) {
+          bytes_allocated_backgrounded +=
+              client_state->managed_memory_stats.bytes_allocated;
+        }
+      }
+      if (allow_allocation_when_backgrounded) {
+        allocation.renderer_allocation.bytes_limit_when_not_visible =
+            GetCurrentBackgroundedAvailableGpuMemory();
+        allocation.renderer_allocation.priority_cutoff_when_not_visible =
+            GpuMemoryAllocationForRenderer::kPriorityCutoffAllowOnlyRequired;
+      } else {
+        allocation.renderer_allocation.bytes_limit_when_not_visible = 0;
+        allocation.renderer_allocation.priority_cutoff_when_not_visible =
+            GpuMemoryAllocationForRenderer::kPriorityCutoffAllowNothing;
+      }
     } else {
       if (!client_state->hibernated) {
         allocation.renderer_allocation.bytes_limit_when_visible =
             GetMinimumTabAllocation();
         allocation.renderer_allocation.priority_cutoff_when_visible =
             GpuMemoryAllocationForRenderer::kPriorityCutoffAllowEverything;
       }
     }
     client_state->client->SetMemoryAllocation(allocation);
   }
@@ skipping 86 matching lines @@
     : client(client),
       has_surface(has_surface),
       visible(visible),
       last_used_time(last_used_time),
       hibernated(false) {
 }
 
 }  // namespace content
 
 #endif