base: Improve DiscardableSharedMemory support for ashmem.

content/common/host_discardable_shared_memory_manager_unittest.cc

 // Copyright 2014 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/host_discardable_shared_memory_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
@@ skipping 60 matching lines @@
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle));
 
   TestDiscardableSharedMemory memory(shared_handle);
   bool rv = memory.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   memcpy(memory.memory(), data, kDataSize);
   memory.SetNow(base::Time::FromDoubleT(1));
   memory.Unlock(0, 0);
 
-  ASSERT_TRUE(memory.Lock(0, 0));
+  ASSERT_EQ(base::DiscardableSharedMemory::SUCCESS, memory.Lock(0, 0));
   EXPECT_EQ(memcmp(data, memory.memory(), kDataSize), 0);
   memory.Unlock(0, 0);
 }
 
 TEST_F(HostDiscardableSharedMemoryManagerTest, Purge) {
   const int kDataSize = 1024;
 
   base::SharedMemoryHandle shared_handle1;
   manager_->AllocateLockedDiscardableSharedMemoryForChild(
       base::GetCurrentProcessHandle(), kDataSize, &shared_handle1);
@@ skipping 23 matching lines @@
 
   // Manager should not have to schedule another call to EnforceMemoryPolicy().
   manager_->SetNow(base::Time::FromDoubleT(3));
   manager_->EnforceMemoryPolicy();
   EXPECT_FALSE(manager_->enforce_memory_policy_pending());
 
   // Memory should still be resident.
   EXPECT_TRUE(memory1.IsMemoryResident());
   EXPECT_TRUE(memory2.IsMemoryResident());
 
-  rv = memory1.Lock(0, 0);
-  EXPECT_TRUE(rv);
-  rv = memory2.Lock(0, 0);
-  EXPECT_TRUE(rv);
+  auto lock_rv = memory1.Lock(0, 0);
+  EXPECT_EQ(base::DiscardableSharedMemory::SUCCESS, lock_rv);
+  lock_rv = memory2.Lock(0, 0);
+  EXPECT_EQ(base::DiscardableSharedMemory::SUCCESS, lock_rv);
 
   memory1.SetNow(base::Time::FromDoubleT(4));
   memory1.Unlock(0, 0);
   memory2.SetNow(base::Time::FromDoubleT(5));
   memory2.Unlock(0, 0);
 
   // Just enough memory for one allocation.
   manager_->SetNow(base::Time::FromDoubleT(6));
   manager_->SetMemoryLimit(memory2.mapped_size());
   EXPECT_FALSE(manager_->enforce_memory_policy_pending());
 
   // LRU allocation should still be resident.
   EXPECT_FALSE(memory1.IsMemoryResident());
   EXPECT_TRUE(memory2.IsMemoryResident());
 
-  rv = memory1.Lock(0, 0);
-  EXPECT_FALSE(rv);
-  rv = memory2.Lock(0, 0);
-  EXPECT_TRUE(rv);
+  lock_rv = memory1.Lock(0, 0);
+  EXPECT_EQ(base::DiscardableSharedMemory::FAILED, lock_rv);
+  lock_rv = memory2.Lock(0, 0);
+  EXPECT_EQ(base::DiscardableSharedMemory::SUCCESS, lock_rv);
 }
 
 TEST_F(HostDiscardableSharedMemoryManagerTest, EnforceMemoryPolicy) {
   const int kDataSize = 1024;
 
   base::SharedMemoryHandle shared_handle;
   manager_->AllocateLockedDiscardableSharedMemoryForChild(
       base::GetCurrentProcessHandle(), kDataSize, &shared_handle);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle));
 
@@ skipping 16 matching lines @@
 
   memory.SetNow(base::Time::FromDoubleT(3));
   memory.Unlock(0, 0);
 
   manager_->set_enforce_memory_policy_pending(false);
   manager_->SetNow(base::Time::FromDoubleT(4));
   manager_->EnforceMemoryPolicy();
   // Memory policy should have successfully been enforced.
   EXPECT_FALSE(manager_->enforce_memory_policy_pending());
 
-  EXPECT_FALSE(memory.Lock(0, 0));
+  EXPECT_EQ(base::DiscardableSharedMemory::FAILED, memory.Lock(0, 0));
 }
 
 }  // namespace
 }  // namespace content