Distribute extra memory evenly among visible tabs

content/common/gpu/gpu_memory_manager.cc

Index: content/common/gpu/gpu_memory_manager.cc
diff --git a/content/common/gpu/gpu_memory_manager.cc b/content/common/gpu/gpu_memory_manager.cc
index 07a4d10782dc6521cfd449c9d0a82156ec00c0b6..8c868fa22db735692a75106d6cbfd17357ad0e28 100644
--- a/content/common/gpu/gpu_memory_manager.cc
+++ b/content/common/gpu/gpu_memory_manager.cc
@@ -531,6 +531,9 @@ uint64 GpuMemoryManager::ComputeCap(
   size_t bytes_size = bytes.size();
   uint64 bytes_sum = 0;
 
+  if (bytes_size == 0)
+    return std::numeric_limits<uint64>::max();
+
   // Sort and add up all entries
   std::sort(bytes.begin(), bytes.end());
   for (size_t i = 0; i < bytes_size; ++i)
@@ -791,11 +794,58 @@ void GpuMemoryManager::ComputeNonvisibleSurfacesAllocationsNonuniform() {
   }
 }
 
+void GpuMemoryManager::DistributeRemainingMemoryToVisibleSurfaces() {
+  uint64 bytes_available_total = GetAvailableGpuMemory();
+  uint64 bytes_allocated_total = 0;
+
+  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();

[klobag.chromium, 2013/02/09 04:10:10]

Should we expect the number of client_visible_mru is same as the number of
visible tabs/windows?

Earlier I notices that I have one tab, but there are two entries in the
clients_visible_mru. I believe I was loading gmail.com in Chrome.

[ccameron, 2013/02/09 04:45:28]

We should only have one entry in clients_visible_mru, unless there are two
visible compositor instances (that would be strange, but not out of the real of
possibility).  I'll check this when I'm back at my machine.

[ccameron, 2013/02/11 20:55:56]

I double-checked this an only got 1 visible tab when looking at gmail.

+       it != clients_visible_mru_.end();
+       ++it) {
+    GpuMemoryManagerClientState* client_state = *it;
+    bytes_allocated_total += client_state->bytes_allocation_when_visible_;
+  }
+  for (ClientStateList::const_iterator it = clients_nonvisible_mru_.begin();
+       it != clients_nonvisible_mru_.end();
+       ++it) {
+    GpuMemoryManagerClientState* client_state = *it;
+    bytes_allocated_total += client_state->bytes_allocation_when_nonvisible_;
+  }
+
+  if (bytes_allocated_total >= bytes_available_total)
+    return;
+
+  std::vector<uint64> bytes_extra_requests;
+  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
+       it != clients_visible_mru_.end();
+       ++it) {
+    GpuMemoryManagerClientState* client_state = *it;
+    CHECK(GetMaximumClientAllocation() >=
+          client_state->bytes_allocation_when_visible_);
+    uint64 bytes_extra = GetMaximumClientAllocation() -
+                         client_state->bytes_allocation_when_visible_;
+    bytes_extra_requests.push_back(bytes_extra);
+  }
+  uint64 bytes_extra_cap = ComputeCap(
+      bytes_extra_requests, bytes_available_total - bytes_allocated_total);
+  for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
+       it != clients_visible_mru_.end();
+       ++it) {
+    GpuMemoryManagerClientState* client_state = *it;
+    uint64 bytes_extra = GetMaximumClientAllocation() -
+                         client_state->bytes_allocation_when_visible_;
+    client_state->bytes_allocation_when_visible_ += std::min(
+        bytes_extra, bytes_extra_cap);
+  }
+}
+
 void GpuMemoryManager::AssignSurfacesAllocationsNonuniform() {
   // Compute allocation when for all clients.
   ComputeVisibleSurfacesAllocationsNonuniform();
   ComputeNonvisibleSurfacesAllocationsNonuniform();
 
+  // Distribute the remaining memory to visible clients.
+  DistributeRemainingMemoryToVisibleSurfaces();
+
   // Send that allocation to the clients.
   ClientStateList clients = clients_visible_mru_;
   clients.insert(clients.end(),