Account for unmanaged (e.g, WebGL) use in memory manager

content/common/gpu/gpu_memory_manager_unittest.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_allocation.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_memory_manager_client.h"
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "ui/gfx/size_conversions.h"
 
@@ skipping 127 matching lines @@
   void SetSurfaceSize(gfx::Size size) { surface_size_ = size; }
 
   void SetVisible(bool visible) {
     client_state_->SetVisible(visible);
   }
 
   void SetManagedMemoryStats(const GpuManagedMemoryStats& stats) {
     client_state_->SetManagedMemoryStats(stats);
   }
 
+  size_t BytesWhenVisible() const {
+    return allocation_.renderer_allocation.bytes_limit_when_visible;
+  }
+
   size_t BytesWhenNotVisible() const {
     return allocation_.renderer_allocation.bytes_limit_when_not_visible;
   }
 };
 
 class GpuMemoryManagerTest : public testing::Test {
  protected:
   static const size_t kFrontbufferLimitForTest = 3;
 
   GpuMemoryManagerTest()
@@ skipping 646 matching lines @@
   EXPECT_EQ(memmgr_.bytes_backgrounded_available_gpu_memory_,
             memmgr_.GetCurrentBackgroundedAvailableGpuMemory());
   EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
             stub1.BytesWhenNotVisible());
   EXPECT_EQ(0ul,
             stub2.BytesWhenNotVisible());
   EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
             stub3.BytesWhenNotVisible());
 }
 
+// Test GpuMemoryManager's tracking of unmanaged (e.g, WebGL) memory.
+TEST_F(GpuMemoryManagerTest, TestUnmanagedTracking) {
+  memmgr_.TestingSetAvailableGpuMemory(64);
+  memmgr_.TestingSetBackgroundedAvailableGpuMemory(16);
+  memmgr_.TestingSetUnmanagedLimitStep(16);
+  memmgr_.TestingSetMinimumClientAllocation(8);
+
+  FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
+
+  // Expect that the one stub get the maximum tab allocation.
+  Manage();
+  EXPECT_EQ(memmgr_.GetMaximumTabAllocation(),
+            stub1.BytesWhenVisible());
+
+  // Now allocate some unmanaged memory and make sure the amount
+  // goes down.
+  memmgr_.TrackMemoryAllocatedChange(
+      stub1.tracking_group_.get(),
+      0,
+      48,
+      gpu::gles2::MemoryTracker::kUnmanaged);
+  Manage();
+  EXPECT_GT(memmgr_.GetMaximumTabAllocation(),
+            stub1.BytesWhenVisible());
+
+  // Now allocate the entire FB worth of unmanaged memory, and
+  // make sure that we stay stuck at the minimum tab allocation.
+  memmgr_.TrackMemoryAllocatedChange(
+      stub1.tracking_group_.get(),
+      48,
+      64,
+      gpu::gles2::MemoryTracker::kUnmanaged);
+  Manage();
+  EXPECT_EQ(memmgr_.GetMinimumTabAllocation(),
+            stub1.BytesWhenVisible());
+
+  // Far-oversubscribe the entire FB, and make sure we stay at
+  // the minimum allocation, and don't blow up.
+  memmgr_.TrackMemoryAllocatedChange(
+      stub1.tracking_group_.get(),
+      64,
+      999,
+      gpu::gles2::MemoryTracker::kUnmanaged);
+  Manage();
+  EXPECT_EQ(memmgr_.GetMinimumTabAllocation(),
+            stub1.BytesWhenVisible());
+
+  // Delete all tracked memory so we don't hit leak checks.
+  memmgr_.TrackMemoryAllocatedChange(
+      stub1.tracking_group_.get(),
+      999,
+      0,
+      gpu::gles2::MemoryTracker::kUnmanaged);
+}
+
 }  // namespace content