OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/basictypes.h" | 5 #include "base/basictypes.h" |
6 #include "base/memory/discardable_shared_memory.h" | 6 #include "base/memory/discardable_shared_memory.h" |
7 #include "base/process/process_metrics.h" | 7 #include "base/process/process_metrics.h" |
8 #include "testing/gtest/include/gtest/gtest.h" | 8 #include "testing/gtest/include/gtest/gtest.h" |
9 | 9 |
10 namespace base { | 10 namespace base { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 | 57 |
58 TestDiscardableSharedMemory memory1; | 58 TestDiscardableSharedMemory memory1; |
59 bool rv = memory1.CreateAndMap(kDataSize); | 59 bool rv = memory1.CreateAndMap(kDataSize); |
60 ASSERT_TRUE(rv); | 60 ASSERT_TRUE(rv); |
61 | 61 |
62 // Memory is initially locked. Unlock it. | 62 // Memory is initially locked. Unlock it. |
63 memory1.SetNow(Time::FromDoubleT(1)); | 63 memory1.SetNow(Time::FromDoubleT(1)); |
64 memory1.Unlock(0, 0); | 64 memory1.Unlock(0, 0); |
65 | 65 |
66 // Lock and unlock memory. | 66 // Lock and unlock memory. |
67 rv = memory1.Lock(0, 0); | 67 auto lock_rv = memory1.Lock(0, 0); |
68 EXPECT_TRUE(rv); | 68 EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv); |
69 memory1.SetNow(Time::FromDoubleT(2)); | 69 memory1.SetNow(Time::FromDoubleT(2)); |
70 memory1.Unlock(0, 0); | 70 memory1.Unlock(0, 0); |
71 | 71 |
72 // Lock again before duplicating and passing ownership to new instance. | 72 // Lock again before duplicating and passing ownership to new instance. |
73 rv = memory1.Lock(0, 0); | 73 lock_rv = memory1.Lock(0, 0); |
74 EXPECT_TRUE(rv); | 74 EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv); |
75 | 75 |
76 SharedMemoryHandle shared_handle; | 76 SharedMemoryHandle shared_handle; |
77 ASSERT_TRUE( | 77 ASSERT_TRUE( |
78 memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle)); | 78 memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle)); |
79 ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle)); | 79 ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle)); |
80 | 80 |
81 TestDiscardableSharedMemory memory2(shared_handle); | 81 TestDiscardableSharedMemory memory2(shared_handle); |
82 rv = memory2.Map(kDataSize); | 82 rv = memory2.Map(kDataSize); |
83 ASSERT_TRUE(rv); | 83 ASSERT_TRUE(rv); |
84 | 84 |
85 // Unlock second instance. | 85 // Unlock second instance. |
86 memory2.SetNow(Time::FromDoubleT(3)); | 86 memory2.SetNow(Time::FromDoubleT(3)); |
87 memory2.Unlock(0, 0); | 87 memory2.Unlock(0, 0); |
88 | 88 |
89 // Lock second instance before passing ownership back to first instance. | 89 // Lock second instance before passing ownership back to first instance. |
90 rv = memory2.Lock(0, 0); | 90 lock_rv = memory2.Lock(0, 0); |
91 EXPECT_TRUE(rv); | 91 EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv); |
92 | 92 |
93 // Memory should still be resident. | 93 // Memory should still be resident. |
94 rv = memory1.IsMemoryResident(); | 94 rv = memory1.IsMemoryResident(); |
95 EXPECT_TRUE(rv); | 95 EXPECT_TRUE(rv); |
96 | 96 |
97 // Unlock first instance. | 97 // Unlock first instance. |
98 memory1.SetNow(Time::FromDoubleT(4)); | 98 memory1.SetNow(Time::FromDoubleT(4)); |
99 memory1.Unlock(0, 0); | 99 memory1.Unlock(0, 0); |
100 } | 100 } |
101 | 101 |
(...skipping 26 matching lines...) Expand all Loading... |
128 rv = memory1.Purge(Time::FromDoubleT(3)); | 128 rv = memory1.Purge(Time::FromDoubleT(3)); |
129 EXPECT_FALSE(rv); | 129 EXPECT_FALSE(rv); |
130 | 130 |
131 ASSERT_TRUE(memory2.IsMemoryResident()); | 131 ASSERT_TRUE(memory2.IsMemoryResident()); |
132 | 132 |
133 // Memory is unlocked and our usage timestamp should be correct. | 133 // Memory is unlocked and our usage timestamp should be correct. |
134 rv = memory1.Purge(Time::FromDoubleT(4)); | 134 rv = memory1.Purge(Time::FromDoubleT(4)); |
135 EXPECT_TRUE(rv); | 135 EXPECT_TRUE(rv); |
136 | 136 |
137 // Lock should fail as memory has been purged. | 137 // Lock should fail as memory has been purged. |
138 rv = memory2.Lock(0, 0); | 138 auto lock_rv = memory2.Lock(0, 0); |
139 EXPECT_FALSE(rv); | 139 EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv); |
140 | 140 |
141 ASSERT_FALSE(memory2.IsMemoryResident()); | 141 ASSERT_FALSE(memory2.IsMemoryResident()); |
142 } | 142 } |
143 | 143 |
144 TEST(DiscardableSharedMemoryTest, LastUsed) { | 144 TEST(DiscardableSharedMemoryTest, LastUsed) { |
145 const uint32 kDataSize = 1024; | 145 const uint32 kDataSize = 1024; |
146 | 146 |
147 TestDiscardableSharedMemory memory1; | 147 TestDiscardableSharedMemory memory1; |
148 bool rv = memory1.CreateAndMap(kDataSize); | 148 bool rv = memory1.CreateAndMap(kDataSize); |
149 ASSERT_TRUE(rv); | 149 ASSERT_TRUE(rv); |
150 | 150 |
151 SharedMemoryHandle shared_handle; | 151 SharedMemoryHandle shared_handle; |
152 ASSERT_TRUE( | 152 ASSERT_TRUE( |
153 memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle)); | 153 memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle)); |
154 ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle)); | 154 ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle)); |
155 | 155 |
156 TestDiscardableSharedMemory memory2(shared_handle); | 156 TestDiscardableSharedMemory memory2(shared_handle); |
157 rv = memory2.Map(kDataSize); | 157 rv = memory2.Map(kDataSize); |
158 ASSERT_TRUE(rv); | 158 ASSERT_TRUE(rv); |
159 | 159 |
160 memory2.SetNow(Time::FromDoubleT(1)); | 160 memory2.SetNow(Time::FromDoubleT(1)); |
161 memory2.Unlock(0, 0); | 161 memory2.Unlock(0, 0); |
162 | 162 |
163 EXPECT_EQ(memory2.last_known_usage(), Time::FromDoubleT(1)); | 163 EXPECT_EQ(memory2.last_known_usage(), Time::FromDoubleT(1)); |
164 | 164 |
165 rv = memory2.Lock(0, 0); | 165 auto lock_rv = memory2.Lock(0, 0); |
166 EXPECT_TRUE(rv); | 166 EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv); |
167 | 167 |
168 // This should fail as memory is locked. | 168 // This should fail as memory is locked. |
169 rv = memory1.Purge(Time::FromDoubleT(2)); | 169 rv = memory1.Purge(Time::FromDoubleT(2)); |
170 ASSERT_FALSE(rv); | 170 ASSERT_FALSE(rv); |
171 | 171 |
172 // Last usage should have been updated to timestamp passed to Purge above. | 172 // Last usage should have been updated to timestamp passed to Purge above. |
173 EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(2)); | 173 EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(2)); |
174 | 174 |
175 memory2.SetNow(Time::FromDoubleT(3)); | 175 memory2.SetNow(Time::FromDoubleT(3)); |
176 memory2.Unlock(0, 0); | 176 memory2.Unlock(0, 0); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
225 rv = memory2.Map(kDataSize); | 225 rv = memory2.Map(kDataSize); |
226 ASSERT_TRUE(rv); | 226 ASSERT_TRUE(rv); |
227 | 227 |
228 memory2.SetNow(Time::FromDoubleT(1)); | 228 memory2.SetNow(Time::FromDoubleT(1)); |
229 memory2.Unlock(0, 0); | 229 memory2.Unlock(0, 0); |
230 | 230 |
231 rv = memory2.Purge(Time::FromDoubleT(2)); | 231 rv = memory2.Purge(Time::FromDoubleT(2)); |
232 EXPECT_TRUE(rv); | 232 EXPECT_TRUE(rv); |
233 | 233 |
234 // Lock should fail as memory has been purged. | 234 // Lock should fail as memory has been purged. |
235 rv = memory2.Lock(0, 0); | 235 auto lock_rv = memory2.Lock(0, 0); |
236 EXPECT_FALSE(rv); | 236 EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv); |
237 rv = memory1.Lock(0, 0); | 237 lock_rv = memory1.Lock(0, 0); |
238 EXPECT_FALSE(rv); | 238 EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv); |
239 } | 239 } |
240 | 240 |
241 TEST(DiscardableSharedMemoryTest, LockAndUnlockRange) { | 241 TEST(DiscardableSharedMemoryTest, LockAndUnlockRange) { |
242 const uint32 kDataSize = 32; | 242 const uint32 kDataSize = 32; |
243 | 243 |
244 uint32 data_size_in_bytes = kDataSize * base::GetPageSize(); | 244 uint32 data_size_in_bytes = kDataSize * base::GetPageSize(); |
245 | 245 |
246 TestDiscardableSharedMemory memory1; | 246 TestDiscardableSharedMemory memory1; |
247 bool rv = memory1.CreateAndMap(data_size_in_bytes); | 247 bool rv = memory1.CreateAndMap(data_size_in_bytes); |
248 ASSERT_TRUE(rv); | 248 ASSERT_TRUE(rv); |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
296 | 296 |
297 EXPECT_LE(kDataSize, memory.mapped_size()); | 297 EXPECT_LE(kDataSize, memory.mapped_size()); |
298 | 298 |
299 // Mapped size should be 0 after memory segment has been closed. | 299 // Mapped size should be 0 after memory segment has been closed. |
300 memory.Close(); | 300 memory.Close(); |
301 EXPECT_EQ(0u, memory.mapped_size()); | 301 EXPECT_EQ(0u, memory.mapped_size()); |
302 } | 302 } |
303 | 303 |
304 } // namespace | 304 } // namespace |
305 } // namespace base | 305 } // namespace base |
OLD | NEW |