| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/conflicts/module_database_win.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <memory> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "base/bind.h" | |
| 12 #include "base/memory/ptr_util.h" | |
| 13 #include "base/message_loop/message_loop.h" | |
| 14 #include "base/run_loop.h" | |
| 15 #include "base/strings/utf_string_conversions.h" | |
| 16 #include "base/threading/simple_thread.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 // A simple mechanism for running a single task on a separate thread. | |
| 22 class SingleTaskRunner : public base::SimpleThread { | |
| 23 public: | |
| 24 explicit SingleTaskRunner(base::Closure task) | |
| 25 : base::SimpleThread("SingleTaskRunner"), task_(std::move(task)) {} | |
| 26 | |
| 27 // Runs the provided task and exits. | |
| 28 void Run() override { task_.Run(); } | |
| 29 | |
| 30 private: | |
| 31 base::Closure task_; | |
| 32 DISALLOW_COPY_AND_ASSIGN(SingleTaskRunner); | |
| 33 }; | |
| 34 | |
| 35 // Launches a thread and runs a single task on it. | |
| 36 void RunTask(base::Closure task) { | |
| 37 SingleTaskRunner task_runner(std::move(task)); | |
| 38 task_runner.Start(); | |
| 39 task_runner.Join(); | |
| 40 } | |
| 41 | |
| 42 constexpr uint32_t kPid1 = 1234u; | |
| 43 constexpr uint32_t kPid2 = 2345u; | |
| 44 | |
| 45 constexpr uint64_t kCreateTime1 = 1234u; | |
| 46 constexpr uint64_t kCreateTime2 = 2345u; | |
| 47 | |
| 48 constexpr wchar_t kDll1[] = L"dummy.dll"; | |
| 49 constexpr wchar_t kDll2[] = L"foo.dll"; | |
| 50 | |
| 51 constexpr size_t kSize1 = 100 * 4096; | |
| 52 constexpr size_t kSize2 = 20 * 4096; | |
| 53 | |
| 54 constexpr uint32_t kTime1 = 0xDEADBEEF; | |
| 55 constexpr uint32_t kTime2 = 0xBAADF00D; | |
| 56 | |
| 57 constexpr uintptr_t kGoodAddress1 = 0x04000000u; | |
| 58 constexpr uintptr_t kGoodAddress2 = 0x05000000u; | |
| 59 | |
| 60 } // namespace | |
| 61 | |
| 62 class TestModuleDatabase : ModuleDatabase { | |
| 63 public: | |
| 64 // Types. | |
| 65 using ModuleDatabase::ModuleId; | |
| 66 using ModuleDatabase::ModuleLoadAddresses; | |
| 67 | |
| 68 // Constants. | |
| 69 using ModuleDatabase::kInvalidIndex; | |
| 70 | |
| 71 // Functions. | |
| 72 using ModuleDatabase::FindLoadAddressIndexById; | |
| 73 using ModuleDatabase::FindLoadAddressIndexByAddress; | |
| 74 using ModuleDatabase::InsertLoadAddress; | |
| 75 using ModuleDatabase::RemoveLoadAddressById; | |
| 76 using ModuleDatabase::RemoveLoadAddressByIndex; | |
| 77 }; | |
| 78 | |
| 79 class ModuleDatabaseTest : public testing::Test { | |
| 80 protected: | |
| 81 ModuleDatabaseTest() | |
| 82 : dll1_(kDll1), | |
| 83 dll2_(kDll2), | |
| 84 message_loop_(base::MakeUnique<base::MessageLoop>()), | |
| 85 module_database_( | |
| 86 base::MakeUnique<ModuleDatabase>(message_loop_->task_runner())) {} | |
| 87 | |
| 88 void RunLoopUntilIdle() { base::RunLoop().RunUntilIdle(); } | |
| 89 | |
| 90 const ModuleDatabase::ModuleMap& modules() { | |
| 91 return module_database_->modules_; | |
| 92 } | |
| 93 | |
| 94 const ModuleDatabase::ProcessMap& processes() { | |
| 95 return module_database_->processes_; | |
| 96 } | |
| 97 | |
| 98 static uint32_t ProcessTypeToBit(content::ProcessType process_type) { | |
| 99 return ModuleDatabase::ProcessTypeToBit(process_type); | |
| 100 } | |
| 101 | |
| 102 // Counts the occurrences of the given |module_id| in the given collection of | |
| 103 // |load_addresses|. | |
| 104 static size_t ModuleIdCount( | |
| 105 ModuleDatabase::ModuleId module_id, | |
| 106 const ModuleDatabase::ModuleLoadAddresses& load_addresses) { | |
| 107 return std::count_if( | |
| 108 load_addresses.begin(), load_addresses.end(), | |
| 109 [module_id](const auto& x) { return module_id == x.first; }); | |
| 110 } | |
| 111 | |
| 112 protected: | |
| 113 const base::FilePath dll1_; | |
| 114 const base::FilePath dll2_; | |
| 115 | |
| 116 std::unique_ptr<base::MessageLoop> message_loop_; | |
| 117 std::unique_ptr<ModuleDatabase> module_database_; | |
| 118 | |
| 119 private: | |
| 120 DISALLOW_COPY_AND_ASSIGN(ModuleDatabaseTest); | |
| 121 }; | |
| 122 | |
| 123 TEST_F(ModuleDatabaseTest, LoadAddressVectorOperations) { | |
| 124 using TMD = TestModuleDatabase; | |
| 125 TestModuleDatabase::ModuleLoadAddresses la; | |
| 126 | |
| 127 // Finds should fail in an empty collection. | |
| 128 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0, la)); | |
| 129 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0x04000000, la)); | |
| 130 | |
| 131 // A first insert should work. Don't start with ModuleId 0 so that later | |
| 132 // inserts can insert that module. | |
| 133 TMD::InsertLoadAddress(10, 0x04000000, &la); | |
| 134 EXPECT_EQ(1u, la.size()); | |
| 135 EXPECT_EQ(10, la[0].first); | |
| 136 EXPECT_EQ(0x04000000u, la[0].second); | |
| 137 | |
| 138 // Finds should work. | |
| 139 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0, la)); | |
| 140 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0x03000000, la)); | |
| 141 EXPECT_EQ(0u, TMD::FindLoadAddressIndexById(10, la)); | |
| 142 EXPECT_EQ(0u, TMD::FindLoadAddressIndexByAddress(0x04000000, la)); | |
| 143 | |
| 144 // A second insert should work. This is the new max so should be at the end | |
| 145 // of the collection. | |
| 146 TMD::InsertLoadAddress(12, 0x06000000, &la); | |
| 147 EXPECT_EQ(2u, la.size()); | |
| 148 EXPECT_EQ(10, la[0].first); | |
| 149 EXPECT_EQ(0x04000000u, la[0].second); | |
| 150 EXPECT_EQ(12, la[1].first); | |
| 151 EXPECT_EQ(0x06000000u, la[1].second); | |
| 152 | |
| 153 // Finds should work. | |
| 154 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0, la)); | |
| 155 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0x03000000, la)); | |
| 156 EXPECT_EQ(0u, TMD::FindLoadAddressIndexById(10, la)); | |
| 157 EXPECT_EQ(0u, TMD::FindLoadAddressIndexByAddress(0x04000000, la)); | |
| 158 EXPECT_EQ(1u, TMD::FindLoadAddressIndexById(12, la)); | |
| 159 EXPECT_EQ(1u, TMD::FindLoadAddressIndexByAddress(0x06000000, la)); | |
| 160 | |
| 161 // Another insert should work. This is not the new max, so a swap should | |
| 162 // happen to keep the maximum element at the end of the collection. | |
| 163 TMD::InsertLoadAddress(11, 0x05000000, &la); | |
| 164 EXPECT_EQ(3u, la.size()); | |
| 165 EXPECT_EQ(10, la[0].first); | |
| 166 EXPECT_EQ(0x04000000u, la[0].second); | |
| 167 EXPECT_EQ(11, la[1].first); | |
| 168 EXPECT_EQ(0x05000000u, la[1].second); | |
| 169 EXPECT_EQ(12, la[2].first); | |
| 170 EXPECT_EQ(0x06000000u, la[2].second); | |
| 171 | |
| 172 // An insert of an existing module should work, but simply overwrite the | |
| 173 // load address. | |
| 174 TMD::InsertLoadAddress(11, 0x0F000000, &la); | |
| 175 EXPECT_EQ(3u, la.size()); | |
| 176 EXPECT_EQ(11, la[1].first); | |
| 177 EXPECT_EQ(0x0F000000u, la[1].second); | |
| 178 TMD::InsertLoadAddress(11, 0x05000000, &la); | |
| 179 EXPECT_EQ(3u, la.size()); | |
| 180 EXPECT_EQ(11, la[1].first); | |
| 181 EXPECT_EQ(0x05000000u, la[1].second); | |
| 182 | |
| 183 // Finds should work. | |
| 184 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0, la)); | |
| 185 EXPECT_EQ(TMD::kInvalidIndex, TMD::FindLoadAddressIndexById(0x03000000, la)); | |
| 186 EXPECT_EQ(0u, TMD::FindLoadAddressIndexById(10, la)); | |
| 187 EXPECT_EQ(0u, TMD::FindLoadAddressIndexByAddress(0x04000000, la)); | |
| 188 EXPECT_EQ(1u, TMD::FindLoadAddressIndexById(11, la)); | |
| 189 EXPECT_EQ(1u, TMD::FindLoadAddressIndexByAddress(0x05000000, la)); | |
| 190 EXPECT_EQ(2u, TMD::FindLoadAddressIndexById(12, la)); | |
| 191 EXPECT_EQ(2u, TMD::FindLoadAddressIndexByAddress(0x06000000, la)); | |
| 192 | |
| 193 // Do some inserts of lower modules IDs. This ensures that we'll have some | |
| 194 // higher module IDs in the vector before some lower modules IDs, for testing | |
| 195 // the deletion logic. | |
| 196 TMD::InsertLoadAddress(3, 0x07000000, &la); | |
| 197 TMD::InsertLoadAddress(4, 0x08000000, &la); | |
| 198 TMD::InsertLoadAddress(5, 0x09000000, &la); | |
| 199 EXPECT_EQ(6u, la.size()); | |
| 200 EXPECT_EQ(10, la[0].first); | |
| 201 EXPECT_EQ(0x04000000u, la[0].second); | |
| 202 EXPECT_EQ(11, la[1].first); | |
| 203 EXPECT_EQ(0x05000000u, la[1].second); | |
| 204 EXPECT_EQ(3, la[2].first); | |
| 205 EXPECT_EQ(0x07000000u, la[2].second); | |
| 206 EXPECT_EQ(4, la[3].first); | |
| 207 EXPECT_EQ(0x08000000u, la[3].second); | |
| 208 EXPECT_EQ(5, la[4].first); | |
| 209 EXPECT_EQ(0x09000000u, la[4].second); | |
| 210 EXPECT_EQ(12, la[5].first); | |
| 211 EXPECT_EQ(0x06000000u, la[5].second); | |
| 212 | |
| 213 // Remove an element that isn't in the second last position. The second last | |
| 214 // element should be swapped into its position, and the last element moved | |
| 215 // to the second last place. | |
| 216 TMD::RemoveLoadAddressByIndex(2, &la); | |
| 217 EXPECT_EQ(5u, la.size()); | |
| 218 EXPECT_EQ(10, la[0].first); | |
| 219 EXPECT_EQ(0x04000000u, la[0].second); | |
| 220 EXPECT_EQ(11, la[1].first); | |
| 221 EXPECT_EQ(0x05000000u, la[1].second); | |
| 222 EXPECT_EQ(5, la[2].first); | |
| 223 EXPECT_EQ(0x09000000u, la[2].second); | |
| 224 EXPECT_EQ(4, la[3].first); | |
| 225 EXPECT_EQ(0x08000000u, la[3].second); | |
| 226 EXPECT_EQ(12, la[4].first); | |
| 227 EXPECT_EQ(0x06000000u, la[4].second); | |
| 228 | |
| 229 // Remove the second last element. Only the last element should move. | |
| 230 TMD::RemoveLoadAddressByIndex(3, &la); | |
| 231 EXPECT_EQ(4u, la.size()); | |
| 232 EXPECT_EQ(10, la[0].first); | |
| 233 EXPECT_EQ(0x04000000u, la[0].second); | |
| 234 EXPECT_EQ(11, la[1].first); | |
| 235 EXPECT_EQ(0x05000000u, la[1].second); | |
| 236 EXPECT_EQ(5, la[2].first); | |
| 237 EXPECT_EQ(0x09000000u, la[2].second); | |
| 238 EXPECT_EQ(12, la[3].first); | |
| 239 EXPECT_EQ(0x06000000u, la[3].second); | |
| 240 | |
| 241 // Remove the last element. The new maximum should be found moved to the | |
| 242 // end. | |
| 243 TMD::RemoveLoadAddressByIndex(3, &la); | |
| 244 EXPECT_EQ(3u, la.size()); | |
| 245 EXPECT_EQ(10, la[0].first); | |
| 246 EXPECT_EQ(0x04000000u, la[0].second); | |
| 247 EXPECT_EQ(5, la[1].first); | |
| 248 EXPECT_EQ(0x09000000u, la[1].second); | |
| 249 EXPECT_EQ(11, la[2].first); | |
| 250 EXPECT_EQ(0x05000000u, la[2].second); | |
| 251 | |
| 252 // Remove the last element by ModuleId. The remaining modules should be | |
| 253 // swapped. | |
| 254 TMD::RemoveLoadAddressById(11, &la); | |
| 255 EXPECT_EQ(2u, la.size()); | |
| 256 EXPECT_EQ(5, la[0].first); | |
| 257 EXPECT_EQ(0x09000000u, la[0].second); | |
| 258 EXPECT_EQ(10, la[1].first); | |
| 259 EXPECT_EQ(0x04000000u, la[1].second); | |
| 260 | |
| 261 // Remove the first element by ModuleId. | |
| 262 TMD::RemoveLoadAddressById(5, &la); | |
| 263 EXPECT_EQ(1u, la.size()); | |
| 264 EXPECT_EQ(10, la[0].first); | |
| 265 EXPECT_EQ(0x04000000u, la[0].second); | |
| 266 | |
| 267 // Remove the only remaining element. | |
| 268 TMD::RemoveLoadAddressByIndex(0, &la); | |
| 269 EXPECT_TRUE(la.empty()); | |
| 270 } | |
| 271 | |
| 272 TEST_F(ModuleDatabaseTest, LoadAddressVectorStressTest) { | |
| 273 using TMD = TestModuleDatabase; | |
| 274 TestModuleDatabase::ModuleLoadAddresses la; | |
| 275 | |
| 276 for (size_t n = 1; n < 200; ++n) { | |
| 277 // Will keep track of which elements have been inserted. | |
| 278 std::vector<bool> inserted(n); | |
| 279 size_t inserted_count = 0; | |
| 280 | |
| 281 // Generate a shuffled list of IDs. This will be the insertion order. | |
| 282 // More insertions than elements will occur so that rewrites occur., | |
| 283 std::vector<TMD::ModuleId> ids(11 * n / 10); | |
| 284 for (size_t i = 0; i < 11 * n / 10; ++i) | |
| 285 ids[i] = i % n; | |
| 286 std::random_shuffle(ids.begin(), ids.end()); | |
| 287 | |
| 288 // Do the insertions. | |
| 289 for (auto id : ids) { | |
| 290 if (!inserted[id]) { | |
| 291 inserted[id] = true; | |
| 292 ++inserted_count; | |
| 293 } | |
| 294 | |
| 295 // Generate a load address. The load address bakes in the index so that | |
| 296 // searching by load address is easy. | |
| 297 uintptr_t load_address = static_cast<uintptr_t>(id) << 16; | |
| 298 | |
| 299 // Do the insertion. | |
| 300 TMD::InsertLoadAddress(id, load_address, &la); | |
| 301 EXPECT_EQ(inserted_count, la.size()); | |
| 302 } | |
| 303 | |
| 304 // Validate that every element is there, via both search mechanisms. | |
| 305 for (size_t id = 0; id < n; ++id) { | |
| 306 uintptr_t load_address = static_cast<uintptr_t>(id) << 16; | |
| 307 size_t index1 = TMD::FindLoadAddressIndexById(id, la); | |
| 308 size_t index2 = TMD::FindLoadAddressIndexByAddress(load_address, la); | |
| 309 EXPECT_NE(TMD::kInvalidIndex, index1); | |
| 310 EXPECT_EQ(index1, index2); | |
| 311 } | |
| 312 | |
| 313 // Generate the deletion order. | |
| 314 ids.resize(n); | |
| 315 for (size_t i = 0; i < ids.size(); ++i) | |
| 316 ids[i] = i; | |
| 317 std::random_shuffle(ids.begin(), ids.end()); | |
| 318 | |
| 319 // Do the deletions. | |
| 320 for (auto id : ids) { | |
| 321 --inserted_count; | |
| 322 TMD::RemoveLoadAddressById(id, &la); | |
| 323 EXPECT_EQ(inserted_count, la.size()); | |
| 324 } | |
| 325 } | |
| 326 } | |
| 327 | |
| 328 TEST_F(ModuleDatabaseTest, TasksAreBounced) { | |
| 329 // Run a task on the current thread. This should not be bounced, so no | |
| 330 // task should be scheduled on the task runner. | |
| 331 module_database_->OnProcessStarted(kPid1, kCreateTime1, | |
| 332 content::PROCESS_TYPE_BROWSER); | |
| 333 EXPECT_TRUE(message_loop_->IsIdleForTesting()); | |
| 334 module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1, | |
| 335 kGoodAddress1); | |
| 336 EXPECT_TRUE(message_loop_->IsIdleForTesting()); | |
| 337 module_database_->OnProcessEnded(kPid1, kCreateTime1); | |
| 338 EXPECT_TRUE(message_loop_->IsIdleForTesting()); | |
| 339 | |
| 340 // Indicate another process start on this thread. This call can't be | |
| 341 // bounced. | |
| 342 module_database_->OnProcessStarted(kPid2, kCreateTime2, | |
| 343 content::PROCESS_TYPE_BROWSER); | |
| 344 | |
| 345 // Run similar tasks on another thread. These should be bounced. | |
| 346 RunTask(base::Bind(&ModuleDatabase::OnModuleLoad, | |
| 347 base::Unretained(module_database_.get()), kPid2, | |
| 348 kCreateTime2, dll1_, kSize1, kTime1, kGoodAddress1)); | |
| 349 EXPECT_FALSE(message_loop_->IsIdleForTesting()); | |
| 350 RunLoopUntilIdle(); | |
| 351 | |
| 352 RunTask(base::Bind(&ModuleDatabase::OnProcessEnded, | |
| 353 base::Unretained(module_database_.get()), kPid2, | |
| 354 kCreateTime2)); | |
| 355 EXPECT_FALSE(message_loop_->IsIdleForTesting()); | |
| 356 RunLoopUntilIdle(); | |
| 357 } | |
| 358 | |
| 359 TEST_F(ModuleDatabaseTest, EventsWithoutProcessIgnore) { | |
| 360 EXPECT_EQ(0u, modules().size()); | |
| 361 EXPECT_EQ(0u, processes().size()); | |
| 362 | |
| 363 module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1, | |
| 364 kGoodAddress1); | |
| 365 | |
| 366 EXPECT_EQ(0u, modules().size()); | |
| 367 EXPECT_EQ(0u, processes().size()); | |
| 368 } | |
| 369 | |
| 370 TEST_F(ModuleDatabaseTest, OrphanedUnloadIgnored) { | |
| 371 EXPECT_EQ(0u, modules().size()); | |
| 372 EXPECT_EQ(0u, processes().size()); | |
| 373 | |
| 374 // Start a process. | |
| 375 module_database_->OnProcessStarted(kPid1, kCreateTime1, | |
| 376 content::PROCESS_TYPE_BROWSER); | |
| 377 EXPECT_EQ(0u, modules().size()); | |
| 378 EXPECT_EQ(1u, processes().size()); | |
| 379 auto p1 = processes().begin(); | |
| 380 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 381 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 382 EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type); | |
| 383 EXPECT_EQ(0u, p1->second.loaded_modules.size()); | |
| 384 EXPECT_EQ(0u, p1->second.unloaded_modules.size()); | |
| 385 | |
| 386 // Indicate a module unload. This should do nothing because there's no | |
| 387 // corresponding module. | |
| 388 module_database_->OnModuleUnload(kPid1, kCreateTime1, kGoodAddress1); | |
| 389 EXPECT_EQ(0u, modules().size()); | |
| 390 EXPECT_EQ(1u, processes().size()); | |
| 391 EXPECT_EQ(0u, p1->second.loaded_modules.size()); | |
| 392 EXPECT_EQ(0u, p1->second.unloaded_modules.size()); | |
| 393 } | |
| 394 | |
| 395 TEST_F(ModuleDatabaseTest, DatabaseIsConsistent) { | |
| 396 EXPECT_EQ(0u, modules().size()); | |
| 397 EXPECT_EQ(0u, processes().size()); | |
| 398 | |
| 399 // Start a process. | |
| 400 module_database_->OnProcessStarted(kPid1, kCreateTime1, | |
| 401 content::PROCESS_TYPE_BROWSER); | |
| 402 EXPECT_EQ(0u, modules().size()); | |
| 403 EXPECT_EQ(1u, processes().size()); | |
| 404 auto p1 = processes().begin(); | |
| 405 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 406 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 407 EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type); | |
| 408 EXPECT_EQ(0u, p1->second.loaded_modules.size()); | |
| 409 EXPECT_EQ(0u, p1->second.unloaded_modules.size()); | |
| 410 | |
| 411 // Load a module. | |
| 412 module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1, | |
| 413 kGoodAddress1); | |
| 414 EXPECT_EQ(1u, modules().size()); | |
| 415 EXPECT_EQ(1u, processes().size()); | |
| 416 | |
| 417 // Ensure that the process and module sets are up to date. | |
| 418 auto m1 = modules().begin(); | |
| 419 EXPECT_EQ(dll1_, m1->first.module_path); | |
| 420 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER), | |
| 421 m1->second.process_types); | |
| 422 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 423 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 424 EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type); | |
| 425 EXPECT_EQ(1u, p1->second.loaded_modules.size()); | |
| 426 EXPECT_EQ(0u, p1->second.unloaded_modules.size()); | |
| 427 EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules)); | |
| 428 | |
| 429 // Provide a redundant load message for that module. | |
| 430 module_database_->OnModuleLoad(kPid1, kCreateTime1, dll1_, kSize1, kTime1, | |
| 431 kGoodAddress1); | |
| 432 EXPECT_EQ(1u, modules().size()); | |
| 433 EXPECT_EQ(1u, processes().size()); | |
| 434 | |
| 435 // Ensure that the process and module sets haven't changed. | |
| 436 EXPECT_EQ(dll1_, m1->first.module_path); | |
| 437 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER), | |
| 438 m1->second.process_types); | |
| 439 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 440 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 441 EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type); | |
| 442 EXPECT_EQ(1u, p1->second.loaded_modules.size()); | |
| 443 EXPECT_EQ(0u, p1->second.unloaded_modules.size()); | |
| 444 EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules)); | |
| 445 | |
| 446 // Load a second module into the process. | |
| 447 module_database_->OnModuleLoad(kPid1, kCreateTime1, dll2_, kSize2, kTime2, | |
| 448 kGoodAddress2); | |
| 449 EXPECT_EQ(2u, modules().size()); | |
| 450 EXPECT_EQ(1u, processes().size()); | |
| 451 | |
| 452 // Ensure that the process and module sets are up to date. | |
| 453 auto m2 = modules().rbegin(); | |
| 454 EXPECT_EQ(dll2_, m2->first.module_path); | |
| 455 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER), | |
| 456 m2->second.process_types); | |
| 457 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 458 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 459 EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type); | |
| 460 EXPECT_EQ(2u, p1->second.loaded_modules.size()); | |
| 461 EXPECT_EQ(0u, p1->second.unloaded_modules.size()); | |
| 462 EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules)); | |
| 463 EXPECT_EQ(1u, ModuleIdCount(m2->first.module_id, p1->second.loaded_modules)); | |
| 464 | |
| 465 // Unload the second module. | |
| 466 module_database_->OnModuleUnload(kPid1, kCreateTime1, kGoodAddress2); | |
| 467 EXPECT_EQ(2u, modules().size()); | |
| 468 EXPECT_EQ(1u, processes().size()); | |
| 469 | |
| 470 // Ensure that the process and module sets are up to date. | |
| 471 EXPECT_EQ(dll2_, m2->first.module_path); | |
| 472 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER), | |
| 473 m2->second.process_types); | |
| 474 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 475 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 476 EXPECT_EQ(content::PROCESS_TYPE_BROWSER, p1->first.process_type); | |
| 477 EXPECT_EQ(1u, p1->second.loaded_modules.size()); | |
| 478 EXPECT_EQ(1u, p1->second.unloaded_modules.size()); | |
| 479 EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p1->second.loaded_modules)); | |
| 480 EXPECT_EQ(1u, | |
| 481 ModuleIdCount(m2->first.module_id, p1->second.unloaded_modules)); | |
| 482 | |
| 483 // Start a process. | |
| 484 module_database_->OnProcessStarted(kPid2, kCreateTime2, | |
| 485 content::PROCESS_TYPE_RENDERER); | |
| 486 EXPECT_EQ(2u, modules().size()); | |
| 487 EXPECT_EQ(2u, processes().size()); | |
| 488 auto p2 = processes().rbegin(); | |
| 489 EXPECT_EQ(kPid2, p2->first.process_id); | |
| 490 EXPECT_EQ(kCreateTime2, p2->first.creation_time); | |
| 491 EXPECT_EQ(content::PROCESS_TYPE_RENDERER, p2->first.process_type); | |
| 492 EXPECT_EQ(0u, p2->second.loaded_modules.size()); | |
| 493 EXPECT_EQ(0u, p2->second.unloaded_modules.size()); | |
| 494 | |
| 495 // Load the dummy.dll in the second process as well. | |
| 496 module_database_->OnModuleLoad(kPid2, kCreateTime2, dll1_, kSize1, kTime1, | |
| 497 kGoodAddress1); | |
| 498 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER) | | |
| 499 ProcessTypeToBit(content::PROCESS_TYPE_RENDERER), | |
| 500 m1->second.process_types); | |
| 501 EXPECT_EQ(kPid2, p2->first.process_id); | |
| 502 EXPECT_EQ(kCreateTime2, p2->first.creation_time); | |
| 503 EXPECT_EQ(content::PROCESS_TYPE_RENDERER, p2->first.process_type); | |
| 504 EXPECT_EQ(1u, p2->second.loaded_modules.size()); | |
| 505 EXPECT_EQ(0u, p2->second.unloaded_modules.size()); | |
| 506 EXPECT_EQ(1u, ModuleIdCount(m1->first.module_id, p2->second.loaded_modules)); | |
| 507 | |
| 508 // End the second process without an explicit unload. This invalidates |p2|. | |
| 509 module_database_->OnProcessEnded(kPid2, kCreateTime2); | |
| 510 EXPECT_EQ(2u, modules().size()); | |
| 511 EXPECT_EQ(1u, processes().size()); | |
| 512 EXPECT_EQ(kPid1, p1->first.process_id); | |
| 513 EXPECT_EQ(kCreateTime1, p1->first.creation_time); | |
| 514 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER) | | |
| 515 ProcessTypeToBit(content::PROCESS_TYPE_RENDERER), | |
| 516 m1->second.process_types); | |
| 517 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER), | |
| 518 m2->second.process_types); | |
| 519 | |
| 520 // End the first process without an explicit unload. This invalidates |p1|. | |
| 521 module_database_->OnProcessEnded(kPid1, kCreateTime1); | |
| 522 EXPECT_EQ(2u, modules().size()); | |
| 523 EXPECT_EQ(0u, processes().size()); | |
| 524 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER) | | |
| 525 ProcessTypeToBit(content::PROCESS_TYPE_RENDERER), | |
| 526 m1->second.process_types); | |
| 527 EXPECT_EQ(ProcessTypeToBit(content::PROCESS_TYPE_BROWSER), | |
| 528 m2->second.process_types); | |
| 529 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2634073002:
Revert of [win] Create ModuleDatabase and ModuleEventSinkImpl. (Closed)
