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 #include "components/discardable_memory/service/discardable_shared_memory_manage
r.h" | 4 #include "components/discardable_memory/service/discardable_shared_memory_manage
r.h" |
5 | 5 |
6 #include <stddef.h> | 6 #include <stddef.h> |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <string.h> | 8 #include <string.h> |
9 | 9 |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
70 std::unique_ptr<TestDiscardableSharedMemoryManager> manager_; | 70 std::unique_ptr<TestDiscardableSharedMemoryManager> manager_; |
71 }; | 71 }; |
72 | 72 |
73 TEST_F(DiscardableSharedMemoryManagerTest, AllocateForClient) { | 73 TEST_F(DiscardableSharedMemoryManagerTest, AllocateForClient) { |
74 const int kDataSize = 1024; | 74 const int kDataSize = 1024; |
75 uint8_t data[kDataSize]; | 75 uint8_t data[kDataSize]; |
76 memset(data, 0x80, kDataSize); | 76 memset(data, 0x80, kDataSize); |
77 | 77 |
78 base::SharedMemoryHandle shared_handle; | 78 base::SharedMemoryHandle shared_handle; |
79 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 79 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
80 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 0, | 80 kInvalidUniqueID, kDataSize, 0, &shared_handle); |
81 &shared_handle); | |
82 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle)); | 81 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle)); |
83 | 82 |
84 TestDiscardableSharedMemory memory(shared_handle); | 83 TestDiscardableSharedMemory memory(shared_handle); |
85 bool rv = memory.Map(kDataSize); | 84 bool rv = memory.Map(kDataSize); |
86 ASSERT_TRUE(rv); | 85 ASSERT_TRUE(rv); |
87 | 86 |
88 memcpy(memory.memory(), data, kDataSize); | 87 memcpy(memory.memory(), data, kDataSize); |
89 memory.SetNow(base::Time::FromDoubleT(1)); | 88 memory.SetNow(base::Time::FromDoubleT(1)); |
90 memory.Unlock(0, 0); | 89 memory.Unlock(0, 0); |
91 | 90 |
92 ASSERT_EQ(base::DiscardableSharedMemory::SUCCESS, memory.Lock(0, 0)); | 91 ASSERT_EQ(base::DiscardableSharedMemory::SUCCESS, memory.Lock(0, 0)); |
93 EXPECT_EQ(memcmp(data, memory.memory(), kDataSize), 0); | 92 EXPECT_EQ(memcmp(data, memory.memory(), kDataSize), 0); |
94 memory.Unlock(0, 0); | 93 memory.Unlock(0, 0); |
95 } | 94 } |
96 | 95 |
97 TEST_F(DiscardableSharedMemoryManagerTest, Purge) { | 96 TEST_F(DiscardableSharedMemoryManagerTest, Purge) { |
98 const int kDataSize = 1024; | 97 const int kDataSize = 1024; |
99 | 98 |
100 base::SharedMemoryHandle shared_handle1; | 99 base::SharedMemoryHandle shared_handle1; |
101 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 100 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
102 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 1, | 101 kInvalidUniqueID, kDataSize, 1, &shared_handle1); |
103 &shared_handle1); | |
104 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle1)); | 102 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle1)); |
105 | 103 |
106 TestDiscardableSharedMemory memory1(shared_handle1); | 104 TestDiscardableSharedMemory memory1(shared_handle1); |
107 bool rv = memory1.Map(kDataSize); | 105 bool rv = memory1.Map(kDataSize); |
108 ASSERT_TRUE(rv); | 106 ASSERT_TRUE(rv); |
109 | 107 |
110 base::SharedMemoryHandle shared_handle2; | 108 base::SharedMemoryHandle shared_handle2; |
111 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 109 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
112 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 2, | 110 kInvalidUniqueID, kDataSize, 2, &shared_handle2); |
113 &shared_handle2); | |
114 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle2)); | 111 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle2)); |
115 | 112 |
116 TestDiscardableSharedMemory memory2(shared_handle2); | 113 TestDiscardableSharedMemory memory2(shared_handle2); |
117 rv = memory2.Map(kDataSize); | 114 rv = memory2.Map(kDataSize); |
118 ASSERT_TRUE(rv); | 115 ASSERT_TRUE(rv); |
119 | 116 |
120 // Enough memory for both allocations. | 117 // Enough memory for both allocations. |
121 manager_->SetNow(base::Time::FromDoubleT(1)); | 118 manager_->SetNow(base::Time::FromDoubleT(1)); |
122 manager_->SetMemoryLimit(memory1.mapped_size() + memory2.mapped_size()); | 119 manager_->SetMemoryLimit(memory1.mapped_size() + memory2.mapped_size()); |
123 | 120 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 EXPECT_EQ(base::DiscardableSharedMemory::FAILED, lock_rv); | 155 EXPECT_EQ(base::DiscardableSharedMemory::FAILED, lock_rv); |
159 lock_rv = memory2.Lock(0, 0); | 156 lock_rv = memory2.Lock(0, 0); |
160 EXPECT_EQ(base::DiscardableSharedMemory::SUCCESS, lock_rv); | 157 EXPECT_EQ(base::DiscardableSharedMemory::SUCCESS, lock_rv); |
161 } | 158 } |
162 | 159 |
163 TEST_F(DiscardableSharedMemoryManagerTest, EnforceMemoryPolicy) { | 160 TEST_F(DiscardableSharedMemoryManagerTest, EnforceMemoryPolicy) { |
164 const int kDataSize = 1024; | 161 const int kDataSize = 1024; |
165 | 162 |
166 base::SharedMemoryHandle shared_handle; | 163 base::SharedMemoryHandle shared_handle; |
167 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 164 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
168 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 0, | 165 kInvalidUniqueID, kDataSize, 0, &shared_handle); |
169 &shared_handle); | |
170 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle)); | 166 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle)); |
171 | 167 |
172 TestDiscardableSharedMemory memory(shared_handle); | 168 TestDiscardableSharedMemory memory(shared_handle); |
173 bool rv = memory.Map(kDataSize); | 169 bool rv = memory.Map(kDataSize); |
174 ASSERT_TRUE(rv); | 170 ASSERT_TRUE(rv); |
175 | 171 |
176 // Not enough memory for one allocation. | 172 // Not enough memory for one allocation. |
177 manager_->SetNow(base::Time::FromDoubleT(1)); | 173 manager_->SetNow(base::Time::FromDoubleT(1)); |
178 manager_->SetMemoryLimit(memory.mapped_size() - 1); | 174 manager_->SetMemoryLimit(memory.mapped_size() - 1); |
179 // We need to enforce memory policy as our memory usage is currently above | 175 // We need to enforce memory policy as our memory usage is currently above |
(...skipping 17 matching lines...) Expand all Loading... |
197 | 193 |
198 EXPECT_EQ(base::DiscardableSharedMemory::FAILED, memory.Lock(0, 0)); | 194 EXPECT_EQ(base::DiscardableSharedMemory::FAILED, memory.Lock(0, 0)); |
199 } | 195 } |
200 | 196 |
201 TEST_F(DiscardableSharedMemoryManagerTest, | 197 TEST_F(DiscardableSharedMemoryManagerTest, |
202 ReduceMemoryAfterSegmentHasBeenDeleted) { | 198 ReduceMemoryAfterSegmentHasBeenDeleted) { |
203 const int kDataSize = 1024; | 199 const int kDataSize = 1024; |
204 | 200 |
205 base::SharedMemoryHandle shared_handle1; | 201 base::SharedMemoryHandle shared_handle1; |
206 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 202 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
207 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 1, | 203 kInvalidUniqueID, kDataSize, 1, &shared_handle1); |
208 &shared_handle1); | |
209 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle1)); | 204 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle1)); |
210 | 205 |
211 TestDiscardableSharedMemory memory1(shared_handle1); | 206 TestDiscardableSharedMemory memory1(shared_handle1); |
212 bool rv = memory1.Map(kDataSize); | 207 bool rv = memory1.Map(kDataSize); |
213 ASSERT_TRUE(rv); | 208 ASSERT_TRUE(rv); |
214 | 209 |
215 base::SharedMemoryHandle shared_handle2; | 210 base::SharedMemoryHandle shared_handle2; |
216 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 211 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
217 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 2, | 212 kInvalidUniqueID, kDataSize, 2, &shared_handle2); |
218 &shared_handle2); | |
219 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle2)); | 213 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle2)); |
220 | 214 |
221 TestDiscardableSharedMemory memory2(shared_handle2); | 215 TestDiscardableSharedMemory memory2(shared_handle2); |
222 rv = memory2.Map(kDataSize); | 216 rv = memory2.Map(kDataSize); |
223 ASSERT_TRUE(rv); | 217 ASSERT_TRUE(rv); |
224 | 218 |
225 // Unlock and delete segment 1. | 219 // Unlock and delete segment 1. |
226 memory1.SetNow(base::Time::FromDoubleT(1)); | 220 memory1.SetNow(base::Time::FromDoubleT(1)); |
227 memory1.Unlock(0, 0); | 221 memory1.Unlock(0, 0); |
228 memory1.Unmap(); | 222 memory1.Unmap(); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
262 DiscardableSharedMemoryManager* const manager_; | 256 DiscardableSharedMemoryManager* const manager_; |
263 const size_t limit_; | 257 const size_t limit_; |
264 }; | 258 }; |
265 | 259 |
266 TEST_F(DiscardableSharedMemoryManagerScheduleEnforceMemoryPolicyTest, | 260 TEST_F(DiscardableSharedMemoryManagerScheduleEnforceMemoryPolicyTest, |
267 SetMemoryLimitOnSimpleThread) { | 261 SetMemoryLimitOnSimpleThread) { |
268 const int kDataSize = 1024; | 262 const int kDataSize = 1024; |
269 | 263 |
270 base::SharedMemoryHandle shared_handle; | 264 base::SharedMemoryHandle shared_handle; |
271 manager_->AllocateLockedDiscardableSharedMemoryForClient( | 265 manager_->AllocateLockedDiscardableSharedMemoryForClient( |
272 base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 0, | 266 kInvalidUniqueID, kDataSize, 0, &shared_handle); |
273 &shared_handle); | |
274 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle)); | 267 ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle)); |
275 | 268 |
276 // Set the memory limit to a value that will require EnforceMemoryPolicy() | 269 // Set the memory limit to a value that will require EnforceMemoryPolicy() |
277 // to be schedule on a thread without a message loop. | 270 // to be schedule on a thread without a message loop. |
278 SetMemoryLimitRunner runner(manager_.get(), kDataSize - 1); | 271 SetMemoryLimitRunner runner(manager_.get(), kDataSize - 1); |
279 base::DelegateSimpleThread thread(&runner, "memory_limit_setter"); | 272 base::DelegateSimpleThread thread(&runner, "memory_limit_setter"); |
280 thread.Start(); | 273 thread.Start(); |
281 thread.Join(); | 274 thread.Join(); |
282 } | 275 } |
283 | 276 |
284 } // namespace | 277 } // namespace |
285 } // namespace discardable_memory | 278 } // namespace discardable_memory |
OLD | NEW |