base: Fix parsing and add dalvik-heap-limit

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 208 matching lines @@
 
   void Manage() {
     ClientAssignmentCollector::ClearAllStats();
     memmgr_.Manage();
   }
 
   uint64 CalcAvailableFromGpuTotal(uint64 bytes) {
     return GpuMemoryManager::CalcAvailableFromGpuTotal(bytes);
   }
 
-  uint64 CalcAvailableFromViewportArea(int viewport_area) {
-    return GpuMemoryManager::CalcAvailableFromViewportArea(viewport_area);
-  }
-
   uint64 CalcAvailableClamped(uint64 bytes) {
     bytes = std::max(bytes, memmgr_.GetDefaultAvailableGpuMemory());
     bytes = std::min(bytes, memmgr_.GetMaximumTotalGpuMemory());
     return bytes;
   }
 
   uint64 GetAvailableGpuMemory() {
     return memmgr_.GetAvailableGpuMemory();
   }
 
@@ skipping 268 matching lines @@
     delete stubs[i];
   }
 }
 
 // Test GpuMemoryManager::UpdateAvailableGpuMemory functionality
 TEST_F(GpuMemoryManagerTest, TestUpdateAvailableGpuMemory) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), false),
              stub3(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub4(&memmgr_, GenerateUniqueSurfaceId(), false);
-
-#if defined(OS_ANDROID)
-  // We use the largest visible surface size to calculate the limit
-  stub1.SetSurfaceSize(gfx::Size(1024, 512)); // Surface size
-  stub2.SetSurfaceSize(gfx::Size(2048, 512)); // Larger but not visible.
-  stub3.SetSurfaceSize(gfx::Size(512, 512));  // Visible but smaller.
-  stub4.SetSurfaceSize(gfx::Size(512, 512));  // Not visible and smaller.
-  Manage();
-  uint64 bytes_expected = CalcAvailableFromViewportArea(1024*512);
-#else
-  // We take the lowest GPU's total memory as the limit
+// On Android the dalvik heap size is used instead.
+// TODO(epenner): We should avoid #ifdefs in this test and use
+// a setting instead, so we can test all platform behavior.
+#if !defined(OS_ANDROID)
   uint64 expected = 400 * 1024 * 1024;
   stub1.SetTotalGpuMemory(expected); // GPU Memory
   stub2.SetTotalGpuMemory(expected - 1024 * 1024); // Smaller but not visible.
   stub3.SetTotalGpuMemory(expected + 1024 * 1024); // Visible but larger.
   stub4.SetTotalGpuMemory(expected + 1024 * 1024); // Not visible and larger.
   Manage();
   uint64 bytes_expected = CalcAvailableFromGpuTotal(expected);
+  EXPECT_EQ(GetAvailableGpuMemory(), CalcAvailableClamped(bytes_expected));
 #endif
-  EXPECT_EQ(GetAvailableGpuMemory(), CalcAvailableClamped(bytes_expected));
 }
 
 
 // Test GpuMemoryAllocation comparison operators: Iterate over all possible
 // combinations of gpu_resource_size_in_bytes, suggest_have_backbuffer, and
 // suggest_have_frontbuffer, and make sure allocations with equal values test
 // equal and non equal values test not equal.
 TEST_F(GpuMemoryManagerTest, GpuMemoryAllocationCompareTests) {
   std::vector<int> gpu_resource_size_in_bytes_values;
   gpu_resource_size_in_bytes_values.push_back(0);
@@ skipping 492 matching lines @@
 
   // Expect that a client which has not sent stats receive the
   // default allocation.
   Manage();
   EXPECT_EQ(stub1.BytesWhenVisible(),
             memmgr_.GetDefaultClientAllocation());
   EXPECT_EQ(stub1.BytesWhenNotVisible(), 0u);
 }
 
 }  // namespace content