1 // Copyright 2013 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 "base/cancelable_callback.h" 6 #include "base/command_line.h" 7 #include "base/memory/scoped_ptr.h" 8 #include "base/run_loop.h" 9 #include "base/strings/string_split.h" 10 #include "base/strings/stringprintf.h" 11 #include "base/synchronization/waitable_event.h" 12 #include "base/test/simple_test_clock.h" 13 #include "base/test/test_timeouts.h" 14 #include "chrome/browser/extensions/activity_log/activity_log.h" 15 #include "chrome/browser/extensions/activity_log/counting_policy.h" 16 #include "chrome/browser/extensions/extension_service.h" 17 #include "chrome/browser/extensions/test_extension_system.h" 18 #include "chrome/common/chrome_constants.h" 19 #include "chrome/common/chrome_switches.h" 20 #include "chrome/test/base/chrome_render_view_host_test_harness.h" 21 #include "chrome/test/base/testing_profile.h" 22 #include "content/public/test/test_browser_thread_bundle.h" 23 #include "extensions/common/extension_builder.h" 24 #include "sql/statement.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 27 #if defined(OS_CHROMEOS) 28 #include "chrome/browser/chromeos/login/users/user_manager.h" 29 #include "chrome/browser/chromeos/settings/cros_settings.h" 30 #include "chrome/browser/chromeos/settings/device_settings_service.h" 31 #endif 32 33 using content::BrowserThread; 34 35 namespace extensions { 36 37 class CountingPolicyTest : public testing::Test { 38 public: 39 CountingPolicyTest() 40 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 41 saved_cmdline_(CommandLine::NO_PROGRAM) { 42 #if defined OS_CHROMEOS 43 test_user_manager_.reset(new chromeos::ScopedTestUserManager()); 44 #endif 45 CommandLine command_line(CommandLine::NO_PROGRAM); 46 saved_cmdline_ = *CommandLine::ForCurrentProcess(); 47 profile_.reset(new TestingProfile()); 48 CommandLine::ForCurrentProcess()->AppendSwitch( 49 switches::kEnableExtensionActivityLogging); 50 extension_service_ = static_cast<TestExtensionSystem*>( 51 ExtensionSystem::Get(profile_.get()))->CreateExtensionService 52 (&command_line, base::FilePath(), false); 53 } 54 55 virtual ~CountingPolicyTest() { 56 #if defined OS_CHROMEOS 57 test_user_manager_.reset(); 58 #endif 59 base::RunLoop().RunUntilIdle(); 60 profile_.reset(NULL); 61 base::RunLoop().RunUntilIdle(); 62 // Restore the original command line and undo the affects of SetUp(). 63 *CommandLine::ForCurrentProcess() = saved_cmdline_; 64 } 65 66 // Wait for the task queue for the specified thread to empty. 67 void WaitOnThread(const BrowserThread::ID& thread) { 68 BrowserThread::PostTaskAndReply( 69 thread, 70 FROM_HERE, 71 base::Bind(&base::DoNothing), 72 base::MessageLoop::current()->QuitClosure()); 73 base::MessageLoop::current()->Run(); 74 } 75 76 // A wrapper function for CheckReadFilteredData, so that we don't need to 77 // enter empty string values for parameters we don't care about. 78 void CheckReadData( 79 ActivityLogDatabasePolicy* policy, 80 const std::string& extension_id, 81 int day, 82 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) { 83 CheckReadFilteredData( 84 policy, extension_id, Action::ACTION_ANY, "", "", "", day, checker); 85 } 86 87 // A helper function to call ReadFilteredData on a policy object and wait for 88 // the results to be processed. 89 void CheckReadFilteredData( 90 ActivityLogDatabasePolicy* policy, 91 const std::string& extension_id, 92 const Action::ActionType type, 93 const std::string& api_name, 94 const std::string& page_url, 95 const std::string& arg_url, 96 int day, 97 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) { 98 // Submit a request to the policy to read back some data, and call the 99 // checker function when results are available. This will happen on the 100 // database thread. 101 policy->ReadFilteredData( 102 extension_id, 103 type, 104 api_name, 105 page_url, 106 arg_url, 107 day, 108 base::Bind(&CountingPolicyTest::CheckWrapper, 109 checker, 110 base::MessageLoop::current()->QuitClosure())); 111 112 // Set up a timeout for receiving results; if we haven't received anything 113 // when the timeout triggers then assume that the test is broken. 114 base::CancelableClosure timeout( 115 base::Bind(&CountingPolicyTest::TimeoutCallback)); 116 base::MessageLoop::current()->PostDelayedTask( 117 FROM_HERE, timeout.callback(), TestTimeouts::action_timeout()); 118 119 // Wait for results; either the checker or the timeout callbacks should 120 // cause the main loop to exit. 121 base::MessageLoop::current()->Run(); 122 123 timeout.Cancel(); 124 } 125 126 // A helper function which verifies that the string_ids and url_ids tables in 127 // the database have the specified sizes. 128 static void CheckStringTableSizes(CountingPolicy* policy, 129 int string_size, 130 int url_size) { 131 sql::Connection* db = policy->GetDatabaseConnection(); 132 sql::Statement statement1(db->GetCachedStatement( 133 sql::StatementID(SQL_FROM_HERE), "SELECT COUNT(*) FROM string_ids")); 134 ASSERT_TRUE(statement1.Step()); 135 ASSERT_EQ(string_size, statement1.ColumnInt(0)); 136 137 sql::Statement statement2(db->GetCachedStatement( 138 sql::StatementID(SQL_FROM_HERE), "SELECT COUNT(*) FROM url_ids")); 139 ASSERT_TRUE(statement2.Step()); 140 ASSERT_EQ(url_size, statement2.ColumnInt(0)); 141 } 142 143 // Checks that the number of queued actions to be written out does not exceed 144 // kSizeThresholdForFlush. Runs on the database thread. 145 static void CheckQueueSize(CountingPolicy* policy) { 146 // This should be updated if kSizeThresholdForFlush in activity_database.cc 147 // changes. 148 ASSERT_LE(policy->queued_actions_.size(), 200U); 149 } 150 151 static void CheckWrapper( 152 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker, 153 const base::Closure& done, 154 scoped_ptr<Action::ActionVector> results) { 155 checker.Run(results.Pass()); 156 done.Run(); 157 } 158 159 static void TimeoutCallback() { 160 base::MessageLoop::current()->QuitWhenIdle(); 161 FAIL() << "Policy test timed out waiting for results"; 162 } 163 164 static void RetrieveActions_FetchFilteredActions0( 165 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 166 ASSERT_EQ(0, static_cast<int>(i->size())); 167 } 168 169 static void RetrieveActions_FetchFilteredActions1( 170 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 171 ASSERT_EQ(1, static_cast<int>(i->size())); 172 } 173 174 static void RetrieveActions_FetchFilteredActions2( 175 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 176 ASSERT_EQ(2, static_cast<int>(i->size())); 177 } 178 179 static void RetrieveActions_FetchFilteredActions300( 180 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 181 ASSERT_EQ(300, static_cast<int>(i->size())); 182 } 183 184 static void Arguments_Stripped(scoped_ptr<Action::ActionVector> i) { 185 scoped_refptr<Action> last = i->front(); 186 CheckAction(*last, "odlameecjipmbmbejkplpemijjgpljce", 187 Action::ACTION_API_CALL, "extension.connect", 188 "[\"hello\",\"world\"]", "", "", "", 1); 189 } 190 191 static void Arguments_GetSinglesAction( 192 scoped_ptr<Action::ActionVector> actions) { 193 ASSERT_EQ(1, static_cast<int>(actions->size())); 194 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 195 "", "http://www.google.com/", "", "", 1); 196 } 197 198 static void Arguments_GetTodaysActions( 199 scoped_ptr<Action::ActionVector> actions) { 200 ASSERT_EQ(3, static_cast<int>(actions->size())); 201 CheckAction(*actions->at(0), "punky", Action::ACTION_API_CALL, "brewster", 202 "", "", "", "", 2); 203 CheckAction(*actions->at(1), "punky", Action::ACTION_DOM_ACCESS, "lets", 204 "", "http://www.google.com/", "", "", 1); 205 CheckAction(*actions->at(2), "punky", Action::ACTION_API_CALL, 206 "extension.sendMessage", "[\"not\",\"stripped\"]", "", "", "", 207 1); 208 } 209 210 static void Arguments_GetOlderActions( 211 scoped_ptr<Action::ActionVector> actions) { 212 ASSERT_EQ(2, static_cast<int>(actions->size())); 213 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 214 "", "http://www.google.com/", "", "", 1); 215 CheckAction(*actions->at(1), "punky", Action::ACTION_API_CALL, "brewster", 216 "", "", "", "", 1); 217 } 218 219 static void Arguments_CheckMergeCount( 220 int count, 221 scoped_ptr<Action::ActionVector> actions) { 222 if (count > 0) { 223 ASSERT_EQ(1u, actions->size()); 224 CheckAction(*actions->at(0), "punky", Action::ACTION_API_CALL, "brewster", 225 "", "", "", "", count); 226 } else { 227 ASSERT_EQ(0u, actions->size()); 228 } 229 } 230 231 static void Arguments_CheckMergeCountAndTime( 232 int count, 233 const base::Time& time, 234 scoped_ptr<Action::ActionVector> actions) { 235 if (count > 0) { 236 ASSERT_EQ(1u, actions->size()); 237 CheckAction(*actions->at(0), "punky", Action::ACTION_API_CALL, "brewster", 238 "", "", "", "", count); 239 ASSERT_EQ(time, actions->at(0)->time()); 240 } else { 241 ASSERT_EQ(0u, actions->size()); 242 } 243 } 244 245 static void AllURLsRemoved(scoped_ptr<Action::ActionVector> actions) { 246 ASSERT_EQ(2, static_cast<int>(actions->size())); 247 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 248 "", "", "", "", 1); 249 CheckAction(*actions->at(1), "punky", Action::ACTION_DOM_ACCESS, "lets", 250 "", "", "", "", 1); 251 } 252 253 static void SomeURLsRemoved(scoped_ptr<Action::ActionVector> actions) { 254 // These will be in the vector in reverse time order. 255 ASSERT_EQ(5, static_cast<int>(actions->size())); 256 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 257 "", "http://www.google.com/", "Google", 258 "http://www.args-url.com/", 1); 259 CheckAction(*actions->at(1), "punky", Action::ACTION_DOM_ACCESS, "lets", 260 "", "http://www.google.com/", "Google", "", 1); 261 CheckAction(*actions->at(2), "punky", Action::ACTION_DOM_ACCESS, "lets", 262 "", "", "", "", 1); 263 CheckAction(*actions->at(3), "punky", Action::ACTION_DOM_ACCESS, "lets", 264 "", "", "", "http://www.google.com/", 1); 265 CheckAction(*actions->at(4), "punky", Action::ACTION_DOM_ACCESS, "lets", 266 "", "", "", "", 1); 267 } 268 269 static void CheckDuplicates(scoped_ptr<Action::ActionVector> actions) { 270 ASSERT_EQ(2u, actions->size()); 271 int total_count = 0; 272 for (size_t i = 0; i < actions->size(); i++) { 273 total_count += actions->at(i)->count(); 274 } 275 ASSERT_EQ(3, total_count); 276 } 277 278 static void CheckAction(const Action& action, 279 const std::string& expected_id, 280 const Action::ActionType& expected_type, 281 const std::string& expected_api_name, 282 const std::string& expected_args_str, 283 const std::string& expected_page_url, 284 const std::string& expected_page_title, 285 const std::string& expected_arg_url, 286 int expected_count) { 287 ASSERT_EQ(expected_id, action.extension_id()); 288 ASSERT_EQ(expected_type, action.action_type()); 289 ASSERT_EQ(expected_api_name, action.api_name()); 290 ASSERT_EQ(expected_args_str, 291 ActivityLogPolicy::Util::Serialize(action.args())); 292 ASSERT_EQ(expected_page_url, action.SerializePageUrl()); 293 ASSERT_EQ(expected_page_title, action.page_title()); 294 ASSERT_EQ(expected_arg_url, action.SerializeArgUrl()); 295 ASSERT_EQ(expected_count, action.count()); 296 ASSERT_NE(-1, action.action_id()); 297 } 298 299 // A helper function initializes the policy with a number of actions, calls 300 // RemoveActions on a policy object and then checks the result of the 301 // deletion. 302 void CheckRemoveActions( 303 ActivityLogDatabasePolicy* policy, 304 const std::vector<int64>& action_ids, 305 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) { 306 307 // Use a mock clock to ensure that events are not recorded on the wrong day 308 // when the test is run close to local midnight. 309 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 310 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 311 base::TimeDelta::FromHours(12)); 312 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 313 314 // Record some actions 315 scoped_refptr<Action> action = 316 new Action("punky1", 317 mock_clock->Now() - base::TimeDelta::FromMinutes(40), 318 Action::ACTION_DOM_ACCESS, 319 "lets1"); 320 action->mutable_args()->AppendString("vamoose1"); 321 action->set_page_url(GURL("http://www.google1.com")); 322 action->set_page_title("Google1"); 323 action->set_arg_url(GURL("http://www.args-url1.com")); 324 policy->ProcessAction(action); 325 // Record the same action twice, so there are multiple entries in the 326 // database. 327 policy->ProcessAction(action); 328 329 action = new Action("punky2", 330 mock_clock->Now() - base::TimeDelta::FromMinutes(30), 331 Action::ACTION_API_CALL, 332 "lets2"); 333 action->mutable_args()->AppendString("vamoose2"); 334 action->set_page_url(GURL("http://www.google2.com")); 335 action->set_page_title("Google2"); 336 action->set_arg_url(GURL("http://www.args-url2.com")); 337 policy->ProcessAction(action); 338 // Record the same action twice, so there are multiple entries in the 339 // database. 340 policy->ProcessAction(action); 341 342 // Submit a request to delete actions. 343 policy->RemoveActions(action_ids); 344 345 // Check the result of the deletion. The checker function gets all 346 // activities in the database. 347 CheckReadData(policy, "", -1, checker); 348 349 // Clean database. 350 policy->DeleteDatabase(); 351 } 352 353 static void AllActionsDeleted(scoped_ptr<Action::ActionVector> actions) { 354 ASSERT_EQ(0, static_cast<int>(actions->size())); 355 } 356 357 static void NoActionsDeleted(scoped_ptr<Action::ActionVector> actions) { 358 // These will be in the vector in reverse time order. 359 ASSERT_EQ(2, static_cast<int>(actions->size())); 360 CheckAction(*actions->at(0), 361 "punky2", 362 Action::ACTION_API_CALL, 363 "lets2", 364 "", 365 "http://www.google2.com/", 366 "Google2", 367 "http://www.args-url2.com/", 368 2); 369 ASSERT_EQ(2, actions->at(0)->action_id()); 370 CheckAction(*actions->at(1), 371 "punky1", 372 Action::ACTION_DOM_ACCESS, 373 "lets1", 374 "", 375 "http://www.google1.com/", 376 "Google1", 377 "http://www.args-url1.com/", 378 2); 379 ASSERT_EQ(1, actions->at(1)->action_id()); 380 } 381 382 static void Action1Deleted(scoped_ptr<Action::ActionVector> actions) { 383 // These will be in the vector in reverse time order. 384 ASSERT_EQ(1, static_cast<int>(actions->size())); 385 CheckAction(*actions->at(0), 386 "punky2", 387 Action::ACTION_API_CALL, 388 "lets2", 389 "", 390 "http://www.google2.com/", 391 "Google2", 392 "http://www.args-url2.com/", 393 2); 394 ASSERT_EQ(2, actions->at(0)->action_id()); 395 } 396 397 static void Action2Deleted(scoped_ptr<Action::ActionVector> actions) { 398 // These will be in the vector in reverse time order. 399 ASSERT_EQ(1, static_cast<int>(actions->size())); 400 CheckAction(*actions->at(0), 401 "punky1", 402 Action::ACTION_DOM_ACCESS, 403 "lets1", 404 "", 405 "http://www.google1.com/", 406 "Google1", 407 "http://www.args-url1.com/", 408 2); 409 ASSERT_EQ(1, actions->at(0)->action_id()); 410 } 411 412 protected: 413 ExtensionService* extension_service_; 414 scoped_ptr<TestingProfile> profile_; 415 content::TestBrowserThreadBundle thread_bundle_; 416 // Used to preserve a copy of the original command line. 417 // The test framework will do this itself as well. However, by then, 418 // it is too late to call ActivityLog::RecomputeLoggingIsEnabled() in 419 // TearDown(). 420 CommandLine saved_cmdline_; 421 422 #if defined OS_CHROMEOS 423 chromeos::ScopedTestDeviceSettingsService test_device_settings_service_; 424 chromeos::ScopedTestCrosSettings test_cros_settings_; 425 scoped_ptr<chromeos::ScopedTestUserManager> test_user_manager_; 426 #endif 427 }; 428 429 TEST_F(CountingPolicyTest, Construct) { 430 ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get()); 431 policy->Init(); 432 scoped_refptr<const Extension> extension = 433 ExtensionBuilder() 434 .SetManifest(DictionaryBuilder() 435 .Set("name", "Test extension") 436 .Set("version", "1.0.0") 437 .Set("manifest_version", 2)) 438 .Build(); 439 extension_service_->AddExtension(extension.get()); 440 scoped_ptr<base::ListValue> args(new base::ListValue()); 441 scoped_refptr<Action> action = new Action(extension->id(), 442 base::Time::Now(), 443 Action::ACTION_API_CALL, 444 "tabs.testMethod"); 445 action->set_args(args.Pass()); 446 policy->ProcessAction(action); 447 policy->Close(); 448 } 449 450 TEST_F(CountingPolicyTest, LogWithStrippedArguments) { 451 ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get()); 452 policy->Init(); 453 scoped_refptr<const Extension> extension = 454 ExtensionBuilder() 455 .SetManifest(DictionaryBuilder() 456 .Set("name", "Test extension") 457 .Set("version", "1.0.0") 458 .Set("manifest_version", 2)) 459 .Build(); 460 extension_service_->AddExtension(extension.get()); 461 462 scoped_ptr<base::ListValue> args(new base::ListValue()); 463 args->Set(0, new base::StringValue("hello")); 464 args->Set(1, new base::StringValue("world")); 465 scoped_refptr<Action> action = new Action(extension->id(), 466 base::Time::Now(), 467 Action::ACTION_API_CALL, 468 "extension.connect"); 469 action->set_args(args.Pass()); 470 471 policy->ProcessAction(action); 472 CheckReadData(policy, 473 extension->id(), 474 0, 475 base::Bind(&CountingPolicyTest::Arguments_Stripped)); 476 policy->Close(); 477 } 478 479 TEST_F(CountingPolicyTest, GetTodaysActions) { 480 CountingPolicy* policy = new CountingPolicy(profile_.get()); 481 policy->Init(); 482 // Disable row expiration for this test by setting a time before any actions 483 // we generate. 484 policy->set_retention_time(base::TimeDelta::FromDays(14)); 485 486 // Use a mock clock to ensure that events are not recorded on the wrong day 487 // when the test is run close to local midnight. Note: Ownership is passed 488 // to the policy, but we still keep a pointer locally. The policy will take 489 // care of destruction; this is safe since the policy outlives all our 490 // accesses to the mock clock. 491 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 492 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 493 base::TimeDelta::FromHours(12)); 494 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 495 496 // Record some actions 497 scoped_refptr<Action> action = 498 new Action("punky", 499 mock_clock->Now() - base::TimeDelta::FromMinutes(40), 500 Action::ACTION_API_CALL, 501 "brewster"); 502 action->mutable_args()->AppendString("woof"); 503 policy->ProcessAction(action); 504 505 action = new Action("punky", 506 mock_clock->Now() - base::TimeDelta::FromMinutes(30), 507 Action::ACTION_API_CALL, 508 "brewster"); 509 action->mutable_args()->AppendString("meow"); 510 policy->ProcessAction(action); 511 512 action = new Action("punky", 513 mock_clock->Now() - base::TimeDelta::FromMinutes(20), 514 Action::ACTION_API_CALL, 515 "extension.sendMessage"); 516 action->mutable_args()->AppendString("not"); 517 action->mutable_args()->AppendString("stripped"); 518 policy->ProcessAction(action); 519 520 action = 521 new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 522 action->mutable_args()->AppendString("vamoose"); 523 action->set_page_url(GURL("http://www.google.com")); 524 policy->ProcessAction(action); 525 526 action = new Action( 527 "scoobydoo", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 528 action->mutable_args()->AppendString("vamoose"); 529 action->set_page_url(GURL("http://www.google.com")); 530 policy->ProcessAction(action); 531 532 CheckReadData( 533 policy, 534 "punky", 535 0, 536 base::Bind(&CountingPolicyTest::Arguments_GetTodaysActions)); 537 policy->Close(); 538 } 539 540 // Check that we can read back less recent actions in the db. 541 TEST_F(CountingPolicyTest, GetOlderActions) { 542 CountingPolicy* policy = new CountingPolicy(profile_.get()); 543 policy->Init(); 544 policy->set_retention_time(base::TimeDelta::FromDays(14)); 545 546 // Use a mock clock to ensure that events are not recorded on the wrong day 547 // when the test is run close to local midnight. 548 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 549 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 550 base::TimeDelta::FromHours(12)); 551 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 552 553 // Record some actions 554 scoped_refptr<Action> action = 555 new Action("punky", 556 mock_clock->Now() - base::TimeDelta::FromDays(3) - 557 base::TimeDelta::FromMinutes(40), 558 Action::ACTION_API_CALL, 559 "brewster"); 560 action->mutable_args()->AppendString("woof"); 561 policy->ProcessAction(action); 562 563 action = new Action("punky", 564 mock_clock->Now() - base::TimeDelta::FromDays(3), 565 Action::ACTION_DOM_ACCESS, 566 "lets"); 567 action->mutable_args()->AppendString("vamoose"); 568 action->set_page_url(GURL("http://www.google.com")); 569 policy->ProcessAction(action); 570 571 action = new Action("punky", 572 mock_clock->Now(), 573 Action::ACTION_DOM_ACCESS, 574 "lets"); 575 action->mutable_args()->AppendString("too new"); 576 action->set_page_url(GURL("http://www.google.com")); 577 policy->ProcessAction(action); 578 579 action = new Action("punky", 580 mock_clock->Now() - base::TimeDelta::FromDays(7), 581 Action::ACTION_DOM_ACCESS, 582 "lets"); 583 action->mutable_args()->AppendString("too old"); 584 action->set_page_url(GURL("http://www.google.com")); 585 policy->ProcessAction(action); 586 587 CheckReadData( 588 policy, 589 "punky", 590 3, 591 base::Bind(&CountingPolicyTest::Arguments_GetOlderActions)); 592 593 policy->Close(); 594 } 595 596 TEST_F(CountingPolicyTest, LogAndFetchFilteredActions) { 597 ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get()); 598 policy->Init(); 599 scoped_refptr<const Extension> extension = 600 ExtensionBuilder() 601 .SetManifest(DictionaryBuilder() 602 .Set("name", "Test extension") 603 .Set("version", "1.0.0") 604 .Set("manifest_version", 2)) 605 .Build(); 606 extension_service_->AddExtension(extension.get()); 607 GURL gurl("http://www.google.com"); 608 609 // Write some API calls 610 scoped_refptr<Action> action_api = new Action(extension->id(), 611 base::Time::Now(), 612 Action::ACTION_API_CALL, 613 "tabs.testMethod"); 614 action_api->set_args(make_scoped_ptr(new base::ListValue())); 615 policy->ProcessAction(action_api); 616 617 scoped_refptr<Action> action_dom = new Action(extension->id(), 618 base::Time::Now(), 619 Action::ACTION_DOM_ACCESS, 620 "document.write"); 621 action_dom->set_args(make_scoped_ptr(new base::ListValue())); 622 action_dom->set_page_url(gurl); 623 policy->ProcessAction(action_dom); 624 625 CheckReadFilteredData( 626 policy, 627 extension->id(), 628 Action::ACTION_API_CALL, 629 "tabs.testMethod", 630 "", 631 "", 632 -1, 633 base::Bind( 634 &CountingPolicyTest::RetrieveActions_FetchFilteredActions1)); 635 636 CheckReadFilteredData( 637 policy, 638 "", 639 Action::ACTION_DOM_ACCESS, 640 "", 641 "", 642 "", 643 -1, 644 base::Bind( 645 &CountingPolicyTest::RetrieveActions_FetchFilteredActions1)); 646 647 CheckReadFilteredData( 648 policy, 649 "", 650 Action::ACTION_DOM_ACCESS, 651 "", 652 "http://www.google.com/", 653 "", 654 -1, 655 base::Bind( 656 &CountingPolicyTest::RetrieveActions_FetchFilteredActions1)); 657 658 CheckReadFilteredData( 659 policy, 660 "", 661 Action::ACTION_DOM_ACCESS, 662 "", 663 "http://www.google.com", 664 "", 665 -1, 666 base::Bind( 667 &CountingPolicyTest::RetrieveActions_FetchFilteredActions1)); 668 669 CheckReadFilteredData( 670 policy, 671 "", 672 Action::ACTION_DOM_ACCESS, 673 "", 674 "http://www.goo", 675 "", 676 -1, 677 base::Bind( 678 &CountingPolicyTest::RetrieveActions_FetchFilteredActions1)); 679 680 CheckReadFilteredData( 681 policy, 682 extension->id(), 683 Action::ACTION_ANY, 684 "", 685 "", 686 "", 687 -1, 688 base::Bind( 689 &CountingPolicyTest::RetrieveActions_FetchFilteredActions2)); 690 691 policy->Close(); 692 } 693 694 // Check that merging of actions only occurs within the same day, not across 695 // days, and that old data can be expired from the database. 696 TEST_F(CountingPolicyTest, MergingAndExpiring) { 697 CountingPolicy* policy = new CountingPolicy(profile_.get()); 698 policy->Init(); 699 // Initially disable expiration by setting a retention time before any 700 // actions we generate. 701 policy->set_retention_time(base::TimeDelta::FromDays(14)); 702 703 // Use a mock clock to ensure that events are not recorded on the wrong day 704 // when the test is run close to local midnight. 705 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 706 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 707 base::TimeDelta::FromHours(12)); 708 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 709 710 // The first two actions should be merged; the last one is on a separate day 711 // and should not be. 712 scoped_refptr<Action> action = 713 new Action("punky", 714 mock_clock->Now() - base::TimeDelta::FromDays(3) - 715 base::TimeDelta::FromMinutes(40), 716 Action::ACTION_API_CALL, 717 "brewster"); 718 policy->ProcessAction(action); 719 720 action = new Action("punky", 721 mock_clock->Now() - base::TimeDelta::FromDays(3) - 722 base::TimeDelta::FromMinutes(20), 723 Action::ACTION_API_CALL, 724 "brewster"); 725 policy->ProcessAction(action); 726 727 action = new Action("punky", 728 mock_clock->Now() - base::TimeDelta::FromDays(2) - 729 base::TimeDelta::FromMinutes(20), 730 Action::ACTION_API_CALL, 731 "brewster"); 732 policy->ProcessAction(action); 733 734 CheckReadData(policy, 735 "punky", 736 3, 737 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 2)); 738 CheckReadData(policy, 739 "punky", 740 2, 741 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 1)); 742 743 // Clean actions before midnight two days ago. Force expiration to run by 744 // clearing last_database_cleaning_time_ and submitting a new action. 745 policy->set_retention_time(base::TimeDelta::FromDays(2)); 746 policy->last_database_cleaning_time_ = base::Time(); 747 action = new Action("punky", 748 mock_clock->Now(), 749 Action::ACTION_API_CALL, 750 "brewster"); 751 policy->ProcessAction(action); 752 753 CheckReadData(policy, 754 "punky", 755 3, 756 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 0)); 757 CheckReadData(policy, 758 "punky", 759 2, 760 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 1)); 761 762 policy->Close(); 763 } 764 765 // Test cleaning of old data in the string and URL tables. 766 TEST_F(CountingPolicyTest, StringTableCleaning) { 767 CountingPolicy* policy = new CountingPolicy(profile_.get()); 768 policy->Init(); 769 // Initially disable expiration by setting a retention time before any 770 // actions we generate. 771 policy->set_retention_time(base::TimeDelta::FromDays(14)); 772 773 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 774 mock_clock->SetNow(base::Time::Now()); 775 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 776 777 // Insert an action; this should create entries in both the string table (for 778 // the extension and API name) and the URL table (for page_url). 779 scoped_refptr<Action> action = 780 new Action("punky", 781 mock_clock->Now() - base::TimeDelta::FromDays(7), 782 Action::ACTION_API_CALL, 783 "brewster"); 784 action->set_page_url(GURL("http://www.google.com/")); 785 policy->ProcessAction(action); 786 787 // Add an action which will not be expired, so that some strings will remain 788 // in use. 789 action = new Action( 790 "punky", mock_clock->Now(), Action::ACTION_API_CALL, "tabs.create"); 791 policy->ProcessAction(action); 792 793 // There should now be three strings ("punky", "brewster", "tabs.create") and 794 // one URL in the tables. 795 policy->Flush(); 796 policy->ScheduleAndForget(policy, 797 &CountingPolicyTest::CheckStringTableSizes, 798 3, 799 1); 800 WaitOnThread(BrowserThread::DB); 801 802 // Trigger a cleaning. The oldest action is expired when we submit a 803 // duplicate of the newer action. After this, there should be two strings 804 // and no URLs. 805 policy->set_retention_time(base::TimeDelta::FromDays(2)); 806 policy->last_database_cleaning_time_ = base::Time(); 807 policy->ProcessAction(action); 808 policy->Flush(); 809 policy->ScheduleAndForget(policy, 810 &CountingPolicyTest::CheckStringTableSizes, 811 2, 812 0); 813 WaitOnThread(BrowserThread::DB); 814 815 policy->Close(); 816 } 817 818 // A stress test for memory- and database-based merging of actions. Submit 819 // multiple items, not in chronological order, spanning a few days. Check that 820 // items are merged properly and final timestamps are correct. 821 TEST_F(CountingPolicyTest, MoreMerging) { 822 CountingPolicy* policy = new CountingPolicy(profile_.get()); 823 policy->Init(); 824 policy->set_retention_time(base::TimeDelta::FromDays(14)); 825 826 // Use a mock clock to ensure that events are not recorded on the wrong day 827 // when the test is run close to local midnight. 828 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 829 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 830 base::TimeDelta::FromHours(12)); 831 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 832 833 // Create an action 2 days ago, then 1 day ago, then 2 days ago. Make sure 834 // that we end up with two merged records (one for each day), and each has 835 // the appropriate timestamp. These merges should happen in the database 836 // since the date keeps changing. 837 base::Time time1 = 838 mock_clock->Now() - base::TimeDelta::FromDays(2) - 839 base::TimeDelta::FromMinutes(40); 840 base::Time time2 = 841 mock_clock->Now() - base::TimeDelta::FromDays(1) - 842 base::TimeDelta::FromMinutes(40); 843 base::Time time3 = 844 mock_clock->Now() - base::TimeDelta::FromDays(2) - 845 base::TimeDelta::FromMinutes(20); 846 847 scoped_refptr<Action> action = 848 new Action("punky", time1, Action::ACTION_API_CALL, "brewster"); 849 policy->ProcessAction(action); 850 851 action = new Action("punky", time2, Action::ACTION_API_CALL, "brewster"); 852 policy->ProcessAction(action); 853 854 action = new Action("punky", time3, Action::ACTION_API_CALL, "brewster"); 855 policy->ProcessAction(action); 856 857 CheckReadData( 858 policy, 859 "punky", 860 2, 861 base::Bind( 862 &CountingPolicyTest::Arguments_CheckMergeCountAndTime, 2, time3)); 863 CheckReadData( 864 policy, 865 "punky", 866 1, 867 base::Bind( 868 &CountingPolicyTest::Arguments_CheckMergeCountAndTime, 1, time2)); 869 870 // Create three actions today, where the merges should happen in memory. 871 // Again these are not chronological; timestamp time5 should win out since it 872 // is the latest. 873 base::Time time4 = mock_clock->Now() - base::TimeDelta::FromMinutes(60); 874 base::Time time5 = mock_clock->Now() - base::TimeDelta::FromMinutes(20); 875 base::Time time6 = mock_clock->Now() - base::TimeDelta::FromMinutes(40); 876 877 action = new Action("punky", time4, Action::ACTION_API_CALL, "brewster"); 878 policy->ProcessAction(action); 879 880 action = new Action("punky", time5, Action::ACTION_API_CALL, "brewster"); 881 policy->ProcessAction(action); 882 883 action = new Action("punky", time6, Action::ACTION_API_CALL, "brewster"); 884 policy->ProcessAction(action); 885 886 CheckReadData( 887 policy, 888 "punky", 889 0, 890 base::Bind( 891 &CountingPolicyTest::Arguments_CheckMergeCountAndTime, 3, time5)); 892 policy->Close(); 893 } 894 895 // Check that actions are flushed to disk before letting too many accumulate in 896 // memory. 897 TEST_F(CountingPolicyTest, EarlyFlush) { 898 CountingPolicy* policy = new CountingPolicy(profile_.get()); 899 policy->Init(); 900 901 for (int i = 0; i < 500; i++) { 902 scoped_refptr<Action> action = 903 new Action("punky", 904 base::Time::Now(), 905 Action::ACTION_API_CALL, 906 base::StringPrintf("apicall_%d", i)); 907 policy->ProcessAction(action); 908 } 909 910 policy->ScheduleAndForget(policy, &CountingPolicyTest::CheckQueueSize); 911 WaitOnThread(BrowserThread::DB); 912 913 policy->Close(); 914 } 915 916 TEST_F(CountingPolicyTest, CapReturns) { 917 CountingPolicy* policy = new CountingPolicy(profile_.get()); 918 policy->Init(); 919 920 for (int i = 0; i < 305; i++) { 921 scoped_refptr<Action> action = 922 new Action("punky", 923 base::Time::Now(), 924 Action::ACTION_API_CALL, 925 base::StringPrintf("apicall_%d", i)); 926 policy->ProcessAction(action); 927 } 928 929 policy->Flush(); 930 WaitOnThread(BrowserThread::DB); 931 932 CheckReadFilteredData( 933 policy, 934 "punky", 935 Action::ACTION_ANY, 936 "", 937 "", 938 "", 939 -1, 940 base::Bind( 941 &CountingPolicyTest::RetrieveActions_FetchFilteredActions300)); 942 policy->Close(); 943 } 944 945 TEST_F(CountingPolicyTest, RemoveAllURLs) { 946 ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get()); 947 policy->Init(); 948 949 // Use a mock clock to ensure that events are not recorded on the wrong day 950 // when the test is run close to local midnight. 951 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 952 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 953 base::TimeDelta::FromHours(12)); 954 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 955 956 // Record some actions 957 scoped_refptr<Action> action = 958 new Action("punky", mock_clock->Now(), 959 Action::ACTION_DOM_ACCESS, "lets"); 960 action->mutable_args()->AppendString("vamoose"); 961 action->set_page_url(GURL("http://www.google.com")); 962 action->set_page_title("Google"); 963 action->set_arg_url(GURL("http://www.args-url.com")); 964 policy->ProcessAction(action); 965 966 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 967 action = new Action( 968 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 969 action->mutable_args()->AppendString("vamoose"); 970 action->set_page_url(GURL("http://www.google2.com")); 971 action->set_page_title("Google"); 972 // Deliberately no arg url set to make sure it stills works if there is no arg 973 // url. 974 policy->ProcessAction(action); 975 976 // Clean all the URLs. 977 std::vector<GURL> no_url_restrictions; 978 policy->RemoveURLs(no_url_restrictions); 979 980 CheckReadData( 981 policy, 982 "punky", 983 0, 984 base::Bind(&CountingPolicyTest::AllURLsRemoved)); 985 policy->Close(); 986 } 987 988 TEST_F(CountingPolicyTest, RemoveSpecificURLs) { 989 ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get()); 990 policy->Init(); 991 992 // Use a mock clock to ensure that events are not recorded on the wrong day 993 // when the test is run close to local midnight. 994 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 995 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 996 base::TimeDelta::FromHours(12)); 997 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 998 999 // Record some actions 1000 // This should have the page url and args url cleared. 1001 scoped_refptr<Action> action = new Action("punky", mock_clock->Now(), 1002 Action::ACTION_DOM_ACCESS, "lets"); 1003 action->mutable_args()->AppendString("vamoose"); 1004 action->set_page_url(GURL("http://www.google1.com")); 1005 action->set_page_title("Google"); 1006 action->set_arg_url(GURL("http://www.google1.com")); 1007 policy->ProcessAction(action); 1008 1009 // This should have the page url cleared but not args url. 1010 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 1011 action = new Action( 1012 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1013 action->mutable_args()->AppendString("vamoose"); 1014 action->set_page_url(GURL("http://www.google1.com")); 1015 action->set_page_title("Google"); 1016 action->set_arg_url(GURL("http://www.google.com")); 1017 policy->ProcessAction(action); 1018 1019 // This should have the page url cleared. The args url is deliberately not 1020 // set to make sure this doesn't cause any issues. 1021 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 1022 action = new Action( 1023 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1024 action->mutable_args()->AppendString("vamoose"); 1025 action->set_page_url(GURL("http://www.google2.com")); 1026 action->set_page_title("Google"); 1027 policy->ProcessAction(action); 1028 1029 // This should have the args url cleared but not the page url or page title. 1030 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 1031 action = new Action( 1032 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1033 action->mutable_args()->AppendString("vamoose"); 1034 action->set_page_url(GURL("http://www.google.com")); 1035 action->set_page_title("Google"); 1036 action->set_arg_url(GURL("http://www.google1.com")); 1037 policy->ProcessAction(action); 1038 1039 // This should have neither cleared. 1040 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 1041 action = new Action( 1042 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1043 action->mutable_args()->AppendString("vamoose"); 1044 action->set_page_url(GURL("http://www.google.com")); 1045 action->set_page_title("Google"); 1046 action->set_arg_url(GURL("http://www.args-url.com")); 1047 action->set_count(5); 1048 policy->ProcessAction(action); 1049 1050 // Clean some URLs. 1051 std::vector<GURL> urls; 1052 urls.push_back(GURL("http://www.google1.com")); 1053 urls.push_back(GURL("http://www.google2.com")); 1054 urls.push_back(GURL("http://www.url_not_in_db.com")); 1055 policy->RemoveURLs(urls); 1056 1057 CheckReadData( 1058 policy, 1059 "punky", 1060 0, 1061 base::Bind(&CountingPolicyTest::SomeURLsRemoved)); 1062 policy->Close(); 1063 } 1064 1065 TEST_F(CountingPolicyTest, RemoveExtensionData) { 1066 CountingPolicy* policy = new CountingPolicy(profile_.get()); 1067 policy->Init(); 1068 1069 // Use a mock clock to ensure that events are not recorded on the wrong day 1070 // when the test is run close to local midnight. 1071 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 1072 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 1073 base::TimeDelta::FromHours(12)); 1074 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 1075 1076 // Record some actions 1077 scoped_refptr<Action> action = new Action("deleteextensiondata", 1078 mock_clock->Now(), 1079 Action::ACTION_DOM_ACCESS, 1080 "lets"); 1081 action->mutable_args()->AppendString("vamoose"); 1082 action->set_page_title("Google"); 1083 action->set_arg_url(GURL("http://www.google.com")); 1084 policy->ProcessAction(action); 1085 policy->ProcessAction(action); 1086 policy->ProcessAction(action); 1087 1088 scoped_refptr<Action> action2 = new Action("dontdelete", 1089 mock_clock->Now(), 1090 Action::ACTION_DOM_ACCESS, 1091 "lets"); 1092 action->mutable_args()->AppendString("vamoose"); 1093 action->set_page_title("Google"); 1094 action->set_arg_url(GURL("http://www.google.com")); 1095 policy->ProcessAction(action2); 1096 1097 policy->Flush(); 1098 policy->RemoveExtensionData("deleteextensiondata"); 1099 1100 CheckReadFilteredData( 1101 policy, 1102 "deleteextensiondata", 1103 Action::ACTION_ANY, 1104 "", 1105 "", 1106 "", 1107 -1, 1108 base::Bind( 1109 &CountingPolicyTest::RetrieveActions_FetchFilteredActions0)); 1110 1111 CheckReadFilteredData( 1112 policy, 1113 "dontdelete", 1114 Action::ACTION_ANY, 1115 "", 1116 "", 1117 "", 1118 -1, 1119 base::Bind( 1120 &CountingPolicyTest::RetrieveActions_FetchFilteredActions1)); 1121 policy->Close(); 1122 } 1123 1124 TEST_F(CountingPolicyTest, DeleteDatabase) { 1125 CountingPolicy* policy = new CountingPolicy(profile_.get()); 1126 policy->Init(); 1127 // Disable row expiration for this test by setting a time before any actions 1128 // we generate. 1129 policy->set_retention_time(base::TimeDelta::FromDays(14)); 1130 1131 // Use a mock clock to ensure that events are not recorded on the wrong day 1132 // when the test is run close to local midnight. Note: Ownership is passed 1133 // to the policy, but we still keep a pointer locally. The policy will take 1134 // care of destruction; this is safe since the policy outlives all our 1135 // accesses to the mock clock. 1136 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 1137 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 1138 base::TimeDelta::FromHours(12)); 1139 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 1140 1141 // Record some actions 1142 scoped_refptr<Action> action = 1143 new Action("punky", 1144 mock_clock->Now() - base::TimeDelta::FromMinutes(40), 1145 Action::ACTION_API_CALL, 1146 "brewster"); 1147 action->mutable_args()->AppendString("woof"); 1148 policy->ProcessAction(action); 1149 1150 action = new Action("punky", 1151 mock_clock->Now() - base::TimeDelta::FromMinutes(30), 1152 Action::ACTION_API_CALL, 1153 "brewster"); 1154 action->mutable_args()->AppendString("meow"); 1155 policy->ProcessAction(action); 1156 1157 action = new Action("punky", 1158 mock_clock->Now() - base::TimeDelta::FromMinutes(20), 1159 Action::ACTION_API_CALL, 1160 "extension.sendMessage"); 1161 action->mutable_args()->AppendString("not"); 1162 action->mutable_args()->AppendString("stripped"); 1163 policy->ProcessAction(action); 1164 1165 action = 1166 new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1167 action->mutable_args()->AppendString("vamoose"); 1168 action->set_page_url(GURL("http://www.google.com")); 1169 policy->ProcessAction(action); 1170 1171 action = new Action( 1172 "scoobydoo", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1173 action->mutable_args()->AppendString("vamoose"); 1174 action->set_page_url(GURL("http://www.google.com")); 1175 policy->ProcessAction(action); 1176 1177 CheckReadData( 1178 policy, 1179 "punky", 1180 0, 1181 base::Bind(&CountingPolicyTest::Arguments_GetTodaysActions)); 1182 1183 policy->DeleteDatabase(); 1184 1185 CheckReadFilteredData( 1186 policy, 1187 "", 1188 Action::ACTION_ANY, 1189 "", 1190 "", 1191 "", 1192 -1, 1193 base::Bind( 1194 &CountingPolicyTest::RetrieveActions_FetchFilteredActions0)); 1195 1196 // The following code tests that the caches of url and string tables were 1197 // cleared by the deletion above. 1198 // https://code.google.com/p/chromium/issues/detail?id=341674. 1199 action = 1200 new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 1201 action->mutable_args()->AppendString("vamoose"); 1202 action->set_page_url(GURL("http://www.google.com")); 1203 policy->ProcessAction(action); 1204 1205 CheckReadData( 1206 policy, 1207 "", 1208 -1, 1209 base::Bind(&CountingPolicyTest::Arguments_GetSinglesAction)); 1210 1211 policy->DeleteDatabase(); 1212 1213 CheckReadFilteredData( 1214 policy, 1215 "", 1216 Action::ACTION_ANY, 1217 "", 1218 "", 1219 "", 1220 -1, 1221 base::Bind( 1222 &CountingPolicyTest::RetrieveActions_FetchFilteredActions0)); 1223 1224 policy->Close(); 1225 } 1226 1227 // Tests that duplicate rows in the activity log database are handled properly 1228 // when updating counts. 1229 TEST_F(CountingPolicyTest, DuplicateRows) { 1230 CountingPolicy* policy = new CountingPolicy(profile_.get()); 1231 policy->Init(); 1232 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 1233 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 1234 base::TimeDelta::FromHours(12)); 1235 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 1236 1237 // Record two actions with distinct URLs. 1238 scoped_refptr<Action> action; 1239 action = new Action( 1240 "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster"); 1241 action->set_page_url(GURL("http://www.google.com")); 1242 policy->ProcessAction(action); 1243 1244 action = new Action( 1245 "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster"); 1246 action->set_page_url(GURL("http://www.google.co.uk")); 1247 policy->ProcessAction(action); 1248 1249 // Manipulate the database to clear the URLs, so that we end up with 1250 // duplicate rows. 1251 std::vector<GURL> no_url_restrictions; 1252 policy->RemoveURLs(no_url_restrictions); 1253 1254 // Record one more action, with no URL. This should increment the count on 1255 // one, and exactly one, of the existing rows. 1256 action = new Action( 1257 "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster"); 1258 policy->ProcessAction(action); 1259 1260 CheckReadData( 1261 policy, 1262 "punky", 1263 0, 1264 base::Bind(&CountingPolicyTest::CheckDuplicates)); 1265 policy->Close(); 1266 } 1267 1268 TEST_F(CountingPolicyTest, RemoveActions) { 1269 ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get()); 1270 policy->Init(); 1271 1272 std::vector<int64> action_ids; 1273 1274 CheckRemoveActions( 1275 policy, action_ids, base::Bind(&CountingPolicyTest::NoActionsDeleted)); 1276 1277 action_ids.push_back(-1); 1278 action_ids.push_back(-10); 1279 action_ids.push_back(0); 1280 action_ids.push_back(5); 1281 action_ids.push_back(10); 1282 CheckRemoveActions( 1283 policy, action_ids, base::Bind(&CountingPolicyTest::NoActionsDeleted)); 1284 action_ids.clear(); 1285 1286 for (int i = 0; i < 50; i++) { 1287 action_ids.push_back(i + 3); 1288 } 1289 CheckRemoveActions( 1290 policy, action_ids, base::Bind(&CountingPolicyTest::NoActionsDeleted)); 1291 action_ids.clear(); 1292 1293 // CheckRemoveActions pushes two actions to the Activity Log database with IDs 1294 // 1 and 2. 1295 action_ids.push_back(1); 1296 action_ids.push_back(2); 1297 CheckRemoveActions( 1298 policy, action_ids, base::Bind(&CountingPolicyTest::AllActionsDeleted)); 1299 action_ids.clear(); 1300 1301 action_ids.push_back(1); 1302 CheckRemoveActions( 1303 policy, action_ids, base::Bind(&CountingPolicyTest::Action1Deleted)); 1304 action_ids.clear(); 1305 1306 action_ids.push_back(2); 1307 CheckRemoveActions( 1308 policy, action_ids, base::Bind(&CountingPolicyTest::Action2Deleted)); 1309 action_ids.clear(); 1310 1311 policy->Close(); 1312 } 1313 1314 } // namespace extensions 1315
