src/chrome/browser/extensions/activity_log/counting_policy_unittest.cc

   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/scoped_test_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.get(),
 187                 "odlameecjipmbmbejkplpemijjgpljce",
 188                 Action::ACTION_API_CALL,
 189                 "extension.connect",
 190                 "[\"hello\",\"world\"]",
 191                 "",
 192                 "",
 193                 "",
 194                 1);
 195   }
 196
 197   static void Arguments_GetSinglesAction(
 198       scoped_ptr<Action::ActionVector> actions) {
 199     ASSERT_EQ(1, static_cast<int>(actions->size()));
 200     CheckAction(*actions->at(0).get(),
 201                 "punky",
 202                 Action::ACTION_DOM_ACCESS,
 203                 "lets",
 204                 "",
 205                 "http://www.google.com/",
 206                 "",
 207                 "",
 208                 1);
 209   }
 210
 211   static void Arguments_GetTodaysActions(
 212       scoped_ptr<Action::ActionVector> actions) {
 213     ASSERT_EQ(3, static_cast<int>(actions->size()));
 214     CheckAction(*actions->at(0).get(),
 215                 "punky",
 216                 Action::ACTION_API_CALL,
 217                 "brewster",
 218                 "",
 219                 "",
 220                 "",
 221                 "",
 222                 2);
 223     CheckAction(*actions->at(1).get(),
 224                 "punky",
 225                 Action::ACTION_DOM_ACCESS,
 226                 "lets",
 227                 "",
 228                 "http://www.google.com/",
 229                 "",
 230                 "",
 231                 1);
 232     CheckAction(*actions->at(2).get(),
 233                 "punky",
 234                 Action::ACTION_API_CALL,
 235                 "extension.sendMessage",
 236                 "[\"not\",\"stripped\"]",
 237                 "",
 238                 "",
 239                 "",
 240                 1);
 241   }
 242
 243   static void Arguments_GetOlderActions(
 244       scoped_ptr<Action::ActionVector> actions) {
 245     ASSERT_EQ(2, static_cast<int>(actions->size()));
 246     CheckAction(*actions->at(0).get(),
 247                 "punky",
 248                 Action::ACTION_DOM_ACCESS,
 249                 "lets",
 250                 "",
 251                 "http://www.google.com/",
 252                 "",
 253                 "",
 254                 1);
 255     CheckAction(*actions->at(1).get(),
 256                 "punky",
 257                 Action::ACTION_API_CALL,
 258                 "brewster",
 259                 "",
 260                 "",
 261                 "",
 262                 "",
 263                 1);
 264   }
 265
 266   static void Arguments_CheckMergeCount(
 267       int count,
 268       scoped_ptr<Action::ActionVector> actions) {
 269     if (count > 0) {
 270       ASSERT_EQ(1u, actions->size());
 271       CheckAction(*actions->at(0).get(),
 272                   "punky",
 273                   Action::ACTION_API_CALL,
 274                   "brewster",
 275                   "",
 276                   "",
 277                   "",
 278                   "",
 279                   count);
 280     } else {
 281       ASSERT_EQ(0u, actions->size());
 282     }
 283   }
 284
 285   static void Arguments_CheckMergeCountAndTime(
 286       int count,
 287       const base::Time& time,
 288       scoped_ptr<Action::ActionVector> actions) {
 289     if (count > 0) {
 290       ASSERT_EQ(1u, actions->size());
 291       CheckAction(*actions->at(0).get(),
 292                   "punky",
 293                   Action::ACTION_API_CALL,
 294                   "brewster",
 295                   "",
 296                   "",
 297                   "",
 298                   "",
 299                   count);
 300       ASSERT_EQ(time, actions->at(0)->time());
 301     } else {
 302       ASSERT_EQ(0u, actions->size());
 303     }
 304   }
 305
 306   static void AllURLsRemoved(scoped_ptr<Action::ActionVector> actions) {
 307     ASSERT_EQ(2, static_cast<int>(actions->size()));
 308     CheckAction(*actions->at(0).get(),
 309                 "punky",
 310                 Action::ACTION_DOM_ACCESS,
 311                 "lets",
 312                 "",
 313                 "",
 314                 "",
 315                 "",
 316                 1);
 317     CheckAction(*actions->at(1).get(),
 318                 "punky",
 319                 Action::ACTION_DOM_ACCESS,
 320                 "lets",
 321                 "",
 322                 "",
 323                 "",
 324                 "",
 325                 1);
 326   }
 327
 328   static void SomeURLsRemoved(scoped_ptr<Action::ActionVector> actions) {
 329     // These will be in the vector in reverse time order.
 330     ASSERT_EQ(5, static_cast<int>(actions->size()));
 331     CheckAction(*actions->at(0).get(),
 332                 "punky",
 333                 Action::ACTION_DOM_ACCESS,
 334                 "lets",
 335                 "",
 336                 "http://www.google.com/",
 337                 "Google",
 338                 "http://www.args-url.com/",
 339                 1);
 340     CheckAction(*actions->at(1).get(),
 341                 "punky",
 342                 Action::ACTION_DOM_ACCESS,
 343                 "lets",
 344                 "",
 345                 "http://www.google.com/",
 346                 "Google",
 347                 "",
 348                 1);
 349     CheckAction(*actions->at(2).get(),
 350                 "punky",
 351                 Action::ACTION_DOM_ACCESS,
 352                 "lets",
 353                 "",
 354                 "",
 355                 "",
 356                 "",
 357                 1);
 358     CheckAction(*actions->at(3).get(),
 359                 "punky",
 360                 Action::ACTION_DOM_ACCESS,
 361                 "lets",
 362                 "",
 363                 "",
 364                 "",
 365                 "http://www.google.com/",
 366                 1);
 367     CheckAction(*actions->at(4).get(),
 368                 "punky",
 369                 Action::ACTION_DOM_ACCESS,
 370                 "lets",
 371                 "",
 372                 "",
 373                 "",
 374                 "",
 375                 1);
 376   }
 377
 378   static void CheckDuplicates(scoped_ptr<Action::ActionVector> actions) {
 379     ASSERT_EQ(2u, actions->size());
 380     int total_count = 0;
 381     for (size_t i = 0; i < actions->size(); i++) {
 382       total_count += actions->at(i)->count();
 383     }
 384     ASSERT_EQ(3, total_count);
 385   }
 386
 387   static void CheckAction(const Action& action,
 388                           const std::string& expected_id,
 389                           const Action::ActionType& expected_type,
 390                           const std::string& expected_api_name,
 391                           const std::string& expected_args_str,
 392                           const std::string& expected_page_url,
 393                           const std::string& expected_page_title,
 394                           const std::string& expected_arg_url,
 395                           int expected_count) {
 396     ASSERT_EQ(expected_id, action.extension_id());
 397     ASSERT_EQ(expected_type, action.action_type());
 398     ASSERT_EQ(expected_api_name, action.api_name());
 399     ASSERT_EQ(expected_args_str,
 400               ActivityLogPolicy::Util::Serialize(action.args()));
 401     ASSERT_EQ(expected_page_url, action.SerializePageUrl());
 402     ASSERT_EQ(expected_page_title, action.page_title());
 403     ASSERT_EQ(expected_arg_url, action.SerializeArgUrl());
 404     ASSERT_EQ(expected_count, action.count());
 405     ASSERT_NE(-1, action.action_id());
 406   }
 407
 408   // A helper function initializes the policy with a number of actions, calls
 409   // RemoveActions on a policy object and then checks the result of the
 410   // deletion.
 411   void CheckRemoveActions(
 412       ActivityLogDatabasePolicy* policy,
 413       const std::vector<int64>& action_ids,
 414       const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) {
 415
 416     // Use a mock clock to ensure that events are not recorded on the wrong day
 417     // when the test is run close to local midnight.
 418     base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
 419     mock_clock->SetNow(base::Time::Now().LocalMidnight() +
 420                        base::TimeDelta::FromHours(12));
 421     policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
 422
 423     // Record some actions
 424     scoped_refptr<Action> action =
 425         new Action("punky1",
 426                    mock_clock->Now() - base::TimeDelta::FromMinutes(40),
 427                    Action::ACTION_DOM_ACCESS,
 428                    "lets1");
 429     action->mutable_args()->AppendString("vamoose1");
 430     action->set_page_url(GURL("http://www.google1.com"));
 431     action->set_page_title("Google1");
 432     action->set_arg_url(GURL("http://www.args-url1.com"));
 433     policy->ProcessAction(action);
 434     // Record the same action twice, so there are multiple entries in the
 435     // database.
 436     policy->ProcessAction(action);
 437
 438     action = new Action("punky2",
 439                         mock_clock->Now() - base::TimeDelta::FromMinutes(30),
 440                         Action::ACTION_API_CALL,
 441                         "lets2");
 442     action->mutable_args()->AppendString("vamoose2");
 443     action->set_page_url(GURL("http://www.google2.com"));
 444     action->set_page_title("Google2");
 445     action->set_arg_url(GURL("http://www.args-url2.com"));
 446     policy->ProcessAction(action);
 447     // Record the same action twice, so there are multiple entries in the
 448     // database.
 449     policy->ProcessAction(action);
 450
 451     // Submit a request to delete actions.
 452     policy->RemoveActions(action_ids);
 453
 454     // Check the result of the deletion. The checker function gets all
 455     // activities in the database.
 456     CheckReadData(policy, "", -1, checker);
 457
 458     // Clean database.
 459     policy->DeleteDatabase();
 460   }
 461
 462   static void AllActionsDeleted(scoped_ptr<Action::ActionVector> actions) {
 463     ASSERT_EQ(0, static_cast<int>(actions->size()));
 464   }
 465
 466   static void NoActionsDeleted(scoped_ptr<Action::ActionVector> actions) {
 467     // These will be in the vector in reverse time order.
 468     ASSERT_EQ(2, static_cast<int>(actions->size()));
 469     CheckAction(*actions->at(0).get(),
 470                 "punky2",
 471                 Action::ACTION_API_CALL,
 472                 "lets2",
 473                 "",
 474                 "http://www.google2.com/",
 475                 "Google2",
 476                 "http://www.args-url2.com/",
 477                 2);
 478     ASSERT_EQ(2, actions->at(0)->action_id());
 479     CheckAction(*actions->at(1).get(),
 480                 "punky1",
 481                 Action::ACTION_DOM_ACCESS,
 482                 "lets1",
 483                 "",
 484                 "http://www.google1.com/",
 485                 "Google1",
 486                 "http://www.args-url1.com/",
 487                 2);
 488     ASSERT_EQ(1, actions->at(1)->action_id());
 489   }
 490
 491   static void Action1Deleted(scoped_ptr<Action::ActionVector> actions) {
 492     // These will be in the vector in reverse time order.
 493     ASSERT_EQ(1, static_cast<int>(actions->size()));
 494     CheckAction(*actions->at(0).get(),
 495                 "punky2",
 496                 Action::ACTION_API_CALL,
 497                 "lets2",
 498                 "",
 499                 "http://www.google2.com/",
 500                 "Google2",
 501                 "http://www.args-url2.com/",
 502                 2);
 503     ASSERT_EQ(2, actions->at(0)->action_id());
 504   }
 505
 506   static void Action2Deleted(scoped_ptr<Action::ActionVector> actions) {
 507     // These will be in the vector in reverse time order.
 508     ASSERT_EQ(1, static_cast<int>(actions->size()));
 509     CheckAction(*actions->at(0).get(),
 510                 "punky1",
 511                 Action::ACTION_DOM_ACCESS,
 512                 "lets1",
 513                 "",
 514                 "http://www.google1.com/",
 515                 "Google1",
 516                 "http://www.args-url1.com/",
 517                 2);
 518     ASSERT_EQ(1, actions->at(0)->action_id());
 519   }
 520
 521  protected:
 522   ExtensionService* extension_service_;
 523   scoped_ptr<TestingProfile> profile_;
 524   content::TestBrowserThreadBundle thread_bundle_;
 525   // Used to preserve a copy of the original command line.
 526   // The test framework will do this itself as well. However, by then,
 527   // it is too late to call ActivityLog::RecomputeLoggingIsEnabled() in
 528   // TearDown().
 529   CommandLine saved_cmdline_;
 530
 531 #if defined OS_CHROMEOS
 532   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 533   chromeos::ScopedTestCrosSettings test_cros_settings_;
 534   scoped_ptr<chromeos::ScopedTestUserManager> test_user_manager_;
 535 #endif
 536 };
 537
 538 TEST_F(CountingPolicyTest, Construct) {
 539   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
 540   policy->Init();
 541   scoped_refptr<const Extension> extension =
 542       ExtensionBuilder()
 543           .SetManifest(DictionaryBuilder()
 544                        .Set("name", "Test extension")
 545                        .Set("version", "1.0.0")
 546                        .Set("manifest_version", 2))
 547           .Build();
 548   extension_service_->AddExtension(extension.get());
 549   scoped_ptr<base::ListValue> args(new base::ListValue());
 550   scoped_refptr<Action> action = new Action(extension->id(),
 551                                             base::Time::Now(),
 552                                             Action::ACTION_API_CALL,
 553                                             "tabs.testMethod");
 554   action->set_args(args.Pass());
 555   policy->ProcessAction(action);
 556   policy->Close();
 557 }
 558
 559 TEST_F(CountingPolicyTest, LogWithStrippedArguments) {
 560   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
 561   policy->Init();
 562   scoped_refptr<const Extension> extension =
 563       ExtensionBuilder()
 564           .SetManifest(DictionaryBuilder()
 565                        .Set("name", "Test extension")
 566                        .Set("version", "1.0.0")
 567                        .Set("manifest_version", 2))
 568           .Build();
 569   extension_service_->AddExtension(extension.get());
 570
 571   scoped_ptr<base::ListValue> args(new base::ListValue());
 572   args->Set(0, new base::StringValue("hello"));
 573   args->Set(1, new base::StringValue("world"));
 574   scoped_refptr<Action> action = new Action(extension->id(),
 575                                             base::Time::Now(),
 576                                             Action::ACTION_API_CALL,
 577                                             "extension.connect");
 578   action->set_args(args.Pass());
 579
 580   policy->ProcessAction(action);
 581   CheckReadData(policy,
 582                 extension->id(),
 583                 0,
 584                 base::Bind(&CountingPolicyTest::Arguments_Stripped));
 585   policy->Close();
 586 }
 587
 588 TEST_F(CountingPolicyTest, GetTodaysActions) {
 589   CountingPolicy* policy = new CountingPolicy(profile_.get());
 590   policy->Init();
 591   // Disable row expiration for this test by setting a time before any actions
 592   // we generate.
 593   policy->set_retention_time(base::TimeDelta::FromDays(14));
 594
 595   // Use a mock clock to ensure that events are not recorded on the wrong day
 596   // when the test is run close to local midnight.  Note: Ownership is passed
 597   // to the policy, but we still keep a pointer locally.  The policy will take
 598   // care of destruction; this is safe since the policy outlives all our
 599   // accesses to the mock clock.
 600   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
 601   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
 602                      base::TimeDelta::FromHours(12));
 603   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
 604
 605   // Record some actions
 606   scoped_refptr<Action> action =
 607       new Action("punky",
 608                  mock_clock->Now() - base::TimeDelta::FromMinutes(40),
 609                  Action::ACTION_API_CALL,
 610                  "brewster");
 611   action->mutable_args()->AppendString("woof");
 612   policy->ProcessAction(action);
 613
 614   action = new Action("punky",
 615                       mock_clock->Now() - base::TimeDelta::FromMinutes(30),
 616                       Action::ACTION_API_CALL,
 617                       "brewster");
 618   action->mutable_args()->AppendString("meow");
 619   policy->ProcessAction(action);
 620
 621   action = new Action("punky",
 622                       mock_clock->Now() - base::TimeDelta::FromMinutes(20),
 623                       Action::ACTION_API_CALL,
 624                       "extension.sendMessage");
 625   action->mutable_args()->AppendString("not");
 626   action->mutable_args()->AppendString("stripped");
 627   policy->ProcessAction(action);
 628
 629   action =
 630       new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
 631   action->mutable_args()->AppendString("vamoose");
 632   action->set_page_url(GURL("http://www.google.com"));
 633   policy->ProcessAction(action);
 634
 635   action = new Action(
 636       "scoobydoo", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
 637   action->mutable_args()->AppendString("vamoose");
 638   action->set_page_url(GURL("http://www.google.com"));
 639   policy->ProcessAction(action);
 640
 641   CheckReadData(
 642       policy,
 643       "punky",
 644       0,
 645       base::Bind(&CountingPolicyTest::Arguments_GetTodaysActions));
 646   policy->Close();
 647 }
 648
 649 // Check that we can read back less recent actions in the db.
 650 TEST_F(CountingPolicyTest, GetOlderActions) {
 651   CountingPolicy* policy = new CountingPolicy(profile_.get());
 652   policy->Init();
 653   policy->set_retention_time(base::TimeDelta::FromDays(14));
 654
 655   // Use a mock clock to ensure that events are not recorded on the wrong day
 656   // when the test is run close to local midnight.
 657   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
 658   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
 659                      base::TimeDelta::FromHours(12));
 660   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
 661
 662   // Record some actions
 663   scoped_refptr<Action> action =
 664       new Action("punky",
 665                  mock_clock->Now() - base::TimeDelta::FromDays(3) -
 666                      base::TimeDelta::FromMinutes(40),
 667                  Action::ACTION_API_CALL,
 668                  "brewster");
 669   action->mutable_args()->AppendString("woof");
 670   policy->ProcessAction(action);
 671
 672   action = new Action("punky",
 673                       mock_clock->Now() - base::TimeDelta::FromDays(3),
 674                       Action::ACTION_DOM_ACCESS,
 675                       "lets");
 676   action->mutable_args()->AppendString("vamoose");
 677   action->set_page_url(GURL("http://www.google.com"));
 678   policy->ProcessAction(action);
 679
 680   action = new Action("punky",
 681                       mock_clock->Now(),
 682                       Action::ACTION_DOM_ACCESS,
 683                       "lets");
 684   action->mutable_args()->AppendString("too new");
 685   action->set_page_url(GURL("http://www.google.com"));
 686   policy->ProcessAction(action);
 687
 688   action = new Action("punky",
 689                       mock_clock->Now() - base::TimeDelta::FromDays(7),
 690                       Action::ACTION_DOM_ACCESS,
 691                       "lets");
 692   action->mutable_args()->AppendString("too old");
 693   action->set_page_url(GURL("http://www.google.com"));
 694   policy->ProcessAction(action);
 695
 696   CheckReadData(
 697       policy,
 698       "punky",
 699       3,
 700       base::Bind(&CountingPolicyTest::Arguments_GetOlderActions));
 701
 702   policy->Close();
 703 }
 704
 705 TEST_F(CountingPolicyTest, LogAndFetchFilteredActions) {
 706   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
 707   policy->Init();
 708   scoped_refptr<const Extension> extension =
 709       ExtensionBuilder()
 710           .SetManifest(DictionaryBuilder()
 711                        .Set("name", "Test extension")
 712                        .Set("version", "1.0.0")
 713                        .Set("manifest_version", 2))
 714           .Build();
 715   extension_service_->AddExtension(extension.get());
 716   GURL gurl("http://www.google.com");
 717
 718   // Write some API calls
 719   scoped_refptr<Action> action_api = new Action(extension->id(),
 720                                                 base::Time::Now(),
 721                                                 Action::ACTION_API_CALL,
 722                                                 "tabs.testMethod");
 723   action_api->set_args(make_scoped_ptr(new base::ListValue()));
 724   policy->ProcessAction(action_api);
 725
 726   scoped_refptr<Action> action_dom = new Action(extension->id(),
 727                                                 base::Time::Now(),
 728                                                 Action::ACTION_DOM_ACCESS,
 729                                                 "document.write");
 730   action_dom->set_args(make_scoped_ptr(new base::ListValue()));
 731   action_dom->set_page_url(gurl);
 732   policy->ProcessAction(action_dom);
 733
 734   CheckReadFilteredData(
 735       policy,
 736       extension->id(),
 737       Action::ACTION_API_CALL,
 738       "tabs.testMethod",
 739       "",
 740       "",
 741       -1,
 742       base::Bind(
 743           &CountingPolicyTest::RetrieveActions_FetchFilteredActions1));
 744
 745   CheckReadFilteredData(
 746       policy,
 747       "",
 748       Action::ACTION_DOM_ACCESS,
 749       "",
 750       "",
 751       "",
 752       -1,
 753       base::Bind(
 754           &CountingPolicyTest::RetrieveActions_FetchFilteredActions1));
 755
 756   CheckReadFilteredData(
 757       policy,
 758       "",
 759       Action::ACTION_DOM_ACCESS,
 760       "",
 761       "http://www.google.com/",
 762       "",
 763       -1,
 764       base::Bind(
 765           &CountingPolicyTest::RetrieveActions_FetchFilteredActions1));
 766
 767   CheckReadFilteredData(
 768       policy,
 769       "",
 770       Action::ACTION_DOM_ACCESS,
 771       "",
 772       "http://www.google.com",
 773       "",
 774       -1,
 775       base::Bind(
 776           &CountingPolicyTest::RetrieveActions_FetchFilteredActions1));
 777
 778   CheckReadFilteredData(
 779       policy,
 780       "",
 781       Action::ACTION_DOM_ACCESS,
 782       "",
 783       "http://www.goo",
 784       "",
 785       -1,
 786       base::Bind(
 787           &CountingPolicyTest::RetrieveActions_FetchFilteredActions1));
 788
 789   CheckReadFilteredData(
 790       policy,
 791       extension->id(),
 792       Action::ACTION_ANY,
 793       "",
 794       "",
 795       "",
 796       -1,
 797       base::Bind(
 798           &CountingPolicyTest::RetrieveActions_FetchFilteredActions2));
 799
 800   policy->Close();
 801 }
 802
 803 // Check that merging of actions only occurs within the same day, not across
 804 // days, and that old data can be expired from the database.
 805 TEST_F(CountingPolicyTest, MergingAndExpiring) {
 806   CountingPolicy* policy = new CountingPolicy(profile_.get());
 807   policy->Init();
 808   // Initially disable expiration by setting a retention time before any
 809   // actions we generate.
 810   policy->set_retention_time(base::TimeDelta::FromDays(14));
 811
 812   // Use a mock clock to ensure that events are not recorded on the wrong day
 813   // when the test is run close to local midnight.
 814   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
 815   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
 816                     base::TimeDelta::FromHours(12));
 817   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
 818
 819   // The first two actions should be merged; the last one is on a separate day
 820   // and should not be.
 821   scoped_refptr<Action> action =
 822       new Action("punky",
 823                  mock_clock->Now() - base::TimeDelta::FromDays(3) -
 824                      base::TimeDelta::FromMinutes(40),
 825                  Action::ACTION_API_CALL,
 826                  "brewster");
 827   policy->ProcessAction(action);
 828
 829   action = new Action("punky",
 830                       mock_clock->Now() - base::TimeDelta::FromDays(3) -
 831                           base::TimeDelta::FromMinutes(20),
 832                       Action::ACTION_API_CALL,
 833                       "brewster");
 834   policy->ProcessAction(action);
 835
 836   action = new Action("punky",
 837                       mock_clock->Now() - base::TimeDelta::FromDays(2) -
 838                           base::TimeDelta::FromMinutes(20),
 839                       Action::ACTION_API_CALL,
 840                       "brewster");
 841   policy->ProcessAction(action);
 842
 843   CheckReadData(policy,
 844                 "punky",
 845                 3,
 846                 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 2));
 847   CheckReadData(policy,
 848                 "punky",
 849                 2,
 850                 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 1));
 851
 852   // Clean actions before midnight two days ago.  Force expiration to run by
 853   // clearing last_database_cleaning_time_ and submitting a new action.
 854   policy->set_retention_time(base::TimeDelta::FromDays(2));
 855   policy->last_database_cleaning_time_ = base::Time();
 856   action = new Action("punky",
 857                       mock_clock->Now(),
 858                       Action::ACTION_API_CALL,
 859                       "brewster");
 860   policy->ProcessAction(action);
 861
 862   CheckReadData(policy,
 863                 "punky",
 864                 3,
 865                 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 0));
 866   CheckReadData(policy,
 867                 "punky",
 868                 2,
 869                 base::Bind(&CountingPolicyTest::Arguments_CheckMergeCount, 1));
 870
 871   policy->Close();
 872 }
 873
 874 // Test cleaning of old data in the string and URL tables.
 875 TEST_F(CountingPolicyTest, StringTableCleaning) {
 876   CountingPolicy* policy = new CountingPolicy(profile_.get());
 877   policy->Init();
 878   // Initially disable expiration by setting a retention time before any
 879   // actions we generate.
 880   policy->set_retention_time(base::TimeDelta::FromDays(14));
 881
 882   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
 883   mock_clock->SetNow(base::Time::Now());
 884   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
 885
 886   // Insert an action; this should create entries in both the string table (for
 887   // the extension and API name) and the URL table (for page_url).
 888   scoped_refptr<Action> action =
 889       new Action("punky",
 890                  mock_clock->Now() - base::TimeDelta::FromDays(7),
 891                  Action::ACTION_API_CALL,
 892                  "brewster");
 893   action->set_page_url(GURL("http://www.google.com/"));
 894   policy->ProcessAction(action);
 895
 896   // Add an action which will not be expired, so that some strings will remain
 897   // in use.
 898   action = new Action(
 899       "punky", mock_clock->Now(), Action::ACTION_API_CALL, "tabs.create");
 900   policy->ProcessAction(action);
 901
 902   // There should now be three strings ("punky", "brewster", "tabs.create") and
 903   // one URL in the tables.
 904   policy->Flush();
 905   policy->ScheduleAndForget(policy,
 906                             &CountingPolicyTest::CheckStringTableSizes,
 907                             3,
 908                             1);
 909   WaitOnThread(BrowserThread::DB);
 910
 911   // Trigger a cleaning.  The oldest action is expired when we submit a
 912   // duplicate of the newer action.  After this, there should be two strings
 913   // and no URLs.
 914   policy->set_retention_time(base::TimeDelta::FromDays(2));
 915   policy->last_database_cleaning_time_ = base::Time();
 916   policy->ProcessAction(action);
 917   policy->Flush();
 918   policy->ScheduleAndForget(policy,
 919                             &CountingPolicyTest::CheckStringTableSizes,
 920                             2,
 921                             0);
 922   WaitOnThread(BrowserThread::DB);
 923
 924   policy->Close();
 925 }
 926
 927 // A stress test for memory- and database-based merging of actions.  Submit
 928 // multiple items, not in chronological order, spanning a few days.  Check that
 929 // items are merged properly and final timestamps are correct.
 930 TEST_F(CountingPolicyTest, MoreMerging) {
 931   CountingPolicy* policy = new CountingPolicy(profile_.get());
 932   policy->Init();
 933   policy->set_retention_time(base::TimeDelta::FromDays(14));
 934
 935   // Use a mock clock to ensure that events are not recorded on the wrong day
 936   // when the test is run close to local midnight.
 937   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
 938   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
 939                     base::TimeDelta::FromHours(12));
 940   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
 941
 942   // Create an action 2 days ago, then 1 day ago, then 2 days ago.  Make sure
 943   // that we end up with two merged records (one for each day), and each has
 944   // the appropriate timestamp.  These merges should happen in the database
 945   // since the date keeps changing.
 946   base::Time time1 =
 947       mock_clock->Now() - base::TimeDelta::FromDays(2) -
 948       base::TimeDelta::FromMinutes(40);
 949   base::Time time2 =
 950       mock_clock->Now() - base::TimeDelta::FromDays(1) -
 951       base::TimeDelta::FromMinutes(40);
 952   base::Time time3 =
 953       mock_clock->Now() - base::TimeDelta::FromDays(2) -
 954       base::TimeDelta::FromMinutes(20);
 955
 956   scoped_refptr<Action> action =
 957       new Action("punky", time1, Action::ACTION_API_CALL, "brewster");
 958   policy->ProcessAction(action);
 959
 960   action = new Action("punky", time2, Action::ACTION_API_CALL, "brewster");
 961   policy->ProcessAction(action);
 962
 963   action = new Action("punky", time3, Action::ACTION_API_CALL, "brewster");
 964   policy->ProcessAction(action);
 965
 966   CheckReadData(
 967       policy,
 968       "punky",
 969       2,
 970       base::Bind(
 971           &CountingPolicyTest::Arguments_CheckMergeCountAndTime, 2, time3));
 972   CheckReadData(
 973       policy,
 974       "punky",
 975       1,
 976       base::Bind(
 977           &CountingPolicyTest::Arguments_CheckMergeCountAndTime, 1, time2));
 978
 979   // Create three actions today, where the merges should happen in memory.
 980   // Again these are not chronological; timestamp time5 should win out since it
 981   // is the latest.
 982   base::Time time4 = mock_clock->Now() - base::TimeDelta::FromMinutes(60);
 983   base::Time time5 = mock_clock->Now() - base::TimeDelta::FromMinutes(20);
 984   base::Time time6 = mock_clock->Now() - base::TimeDelta::FromMinutes(40);
 985
 986   action = new Action("punky", time4, Action::ACTION_API_CALL, "brewster");
 987   policy->ProcessAction(action);
 988
 989   action = new Action("punky", time5, Action::ACTION_API_CALL, "brewster");
 990   policy->ProcessAction(action);
 991
 992   action = new Action("punky", time6, Action::ACTION_API_CALL, "brewster");
 993   policy->ProcessAction(action);
 994
 995   CheckReadData(
 996       policy,
 997       "punky",
 998       0,
 999       base::Bind(
1000           &CountingPolicyTest::Arguments_CheckMergeCountAndTime, 3, time5));
1001   policy->Close();
1002 }
1003
1004 // Check that actions are flushed to disk before letting too many accumulate in
1005 // memory.
1006 TEST_F(CountingPolicyTest, EarlyFlush) {
1007   CountingPolicy* policy = new CountingPolicy(profile_.get());
1008   policy->Init();
1009
1010   for (int i = 0; i < 500; i++) {
1011     scoped_refptr<Action> action =
1012         new Action("punky",
1013                    base::Time::Now(),
1014                    Action::ACTION_API_CALL,
1015                    base::StringPrintf("apicall_%d", i));
1016     policy->ProcessAction(action);
1017   }
1018
1019   policy->ScheduleAndForget(policy, &CountingPolicyTest::CheckQueueSize);
1020   WaitOnThread(BrowserThread::DB);
1021
1022   policy->Close();
1023 }
1024
1025 TEST_F(CountingPolicyTest, CapReturns) {
1026   CountingPolicy* policy = new CountingPolicy(profile_.get());
1027   policy->Init();
1028
1029   for (int i = 0; i < 305; i++) {
1030     scoped_refptr<Action> action =
1031         new Action("punky",
1032                    base::Time::Now(),
1033                    Action::ACTION_API_CALL,
1034                    base::StringPrintf("apicall_%d", i));
1035     policy->ProcessAction(action);
1036   }
1037
1038   policy->Flush();
1039   WaitOnThread(BrowserThread::DB);
1040
1041   CheckReadFilteredData(
1042       policy,
1043       "punky",
1044       Action::ACTION_ANY,
1045       "",
1046       "",
1047       "",
1048       -1,
1049       base::Bind(
1050           &CountingPolicyTest::RetrieveActions_FetchFilteredActions300));
1051   policy->Close();
1052 }
1053
1054 TEST_F(CountingPolicyTest, RemoveAllURLs) {
1055   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
1056   policy->Init();
1057
1058   // Use a mock clock to ensure that events are not recorded on the wrong day
1059   // when the test is run close to local midnight.
1060   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
1061   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
1062                      base::TimeDelta::FromHours(12));
1063   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
1064
1065   // Record some actions
1066   scoped_refptr<Action> action =
1067       new Action("punky", mock_clock->Now(),
1068                  Action::ACTION_DOM_ACCESS, "lets");
1069   action->mutable_args()->AppendString("vamoose");
1070   action->set_page_url(GURL("http://www.google.com"));
1071   action->set_page_title("Google");
1072   action->set_arg_url(GURL("http://www.args-url.com"));
1073   policy->ProcessAction(action);
1074
1075   mock_clock->Advance(base::TimeDelta::FromSeconds(1));
1076   action = new Action(
1077       "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1078   action->mutable_args()->AppendString("vamoose");
1079   action->set_page_url(GURL("http://www.google2.com"));
1080   action->set_page_title("Google");
1081   // Deliberately no arg url set to make sure it stills works if there is no arg
1082   // url.
1083   policy->ProcessAction(action);
1084
1085   // Clean all the URLs.
1086   std::vector<GURL> no_url_restrictions;
1087   policy->RemoveURLs(no_url_restrictions);
1088
1089   CheckReadData(
1090       policy,
1091       "punky",
1092       0,
1093       base::Bind(&CountingPolicyTest::AllURLsRemoved));
1094   policy->Close();
1095 }
1096
1097 TEST_F(CountingPolicyTest, RemoveSpecificURLs) {
1098   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
1099   policy->Init();
1100
1101   // Use a mock clock to ensure that events are not recorded on the wrong day
1102   // when the test is run close to local midnight.
1103   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
1104   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
1105                      base::TimeDelta::FromHours(12));
1106   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
1107
1108   // Record some actions
1109   // This should have the page url and args url cleared.
1110   scoped_refptr<Action> action = new Action("punky", mock_clock->Now(),
1111                                             Action::ACTION_DOM_ACCESS, "lets");
1112   action->mutable_args()->AppendString("vamoose");
1113   action->set_page_url(GURL("http://www.google1.com"));
1114   action->set_page_title("Google");
1115   action->set_arg_url(GURL("http://www.google1.com"));
1116   policy->ProcessAction(action);
1117
1118   // This should have the page url cleared but not args url.
1119   mock_clock->Advance(base::TimeDelta::FromSeconds(1));
1120   action = new Action(
1121       "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1122   action->mutable_args()->AppendString("vamoose");
1123   action->set_page_url(GURL("http://www.google1.com"));
1124   action->set_page_title("Google");
1125   action->set_arg_url(GURL("http://www.google.com"));
1126   policy->ProcessAction(action);
1127
1128   // This should have the page url cleared. The args url is deliberately not
1129   // set to make sure this doesn't cause any issues.
1130   mock_clock->Advance(base::TimeDelta::FromSeconds(1));
1131   action = new Action(
1132       "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1133   action->mutable_args()->AppendString("vamoose");
1134   action->set_page_url(GURL("http://www.google2.com"));
1135   action->set_page_title("Google");
1136   policy->ProcessAction(action);
1137
1138   // This should have the args url cleared but not the page url or page title.
1139   mock_clock->Advance(base::TimeDelta::FromSeconds(1));
1140   action = new Action(
1141       "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1142   action->mutable_args()->AppendString("vamoose");
1143   action->set_page_url(GURL("http://www.google.com"));
1144   action->set_page_title("Google");
1145   action->set_arg_url(GURL("http://www.google1.com"));
1146   policy->ProcessAction(action);
1147
1148   // This should have neither cleared.
1149   mock_clock->Advance(base::TimeDelta::FromSeconds(1));
1150   action = new Action(
1151       "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1152   action->mutable_args()->AppendString("vamoose");
1153   action->set_page_url(GURL("http://www.google.com"));
1154   action->set_page_title("Google");
1155   action->set_arg_url(GURL("http://www.args-url.com"));
1156   action->set_count(5);
1157   policy->ProcessAction(action);
1158
1159     // Clean some URLs.
1160   std::vector<GURL> urls;
1161   urls.push_back(GURL("http://www.google1.com"));
1162   urls.push_back(GURL("http://www.google2.com"));
1163   urls.push_back(GURL("http://www.url_not_in_db.com"));
1164   policy->RemoveURLs(urls);
1165
1166   CheckReadData(
1167       policy,
1168       "punky",
1169       0,
1170       base::Bind(&CountingPolicyTest::SomeURLsRemoved));
1171   policy->Close();
1172 }
1173
1174 TEST_F(CountingPolicyTest, RemoveExtensionData) {
1175   CountingPolicy* policy = new CountingPolicy(profile_.get());
1176   policy->Init();
1177
1178   // Use a mock clock to ensure that events are not recorded on the wrong day
1179   // when the test is run close to local midnight.
1180   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
1181   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
1182                      base::TimeDelta::FromHours(12));
1183   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
1184
1185   // Record some actions
1186   scoped_refptr<Action> action = new Action("deleteextensiondata",
1187                                             mock_clock->Now(),
1188                                             Action::ACTION_DOM_ACCESS,
1189                                             "lets");
1190   action->mutable_args()->AppendString("vamoose");
1191   action->set_page_title("Google");
1192   action->set_arg_url(GURL("http://www.google.com"));
1193   policy->ProcessAction(action);
1194   policy->ProcessAction(action);
1195   policy->ProcessAction(action);
1196
1197   scoped_refptr<Action> action2 = new Action("dontdelete",
1198                                              mock_clock->Now(),
1199                                              Action::ACTION_DOM_ACCESS,
1200                                              "lets");
1201   action->mutable_args()->AppendString("vamoose");
1202   action->set_page_title("Google");
1203   action->set_arg_url(GURL("http://www.google.com"));
1204   policy->ProcessAction(action2);
1205
1206   policy->Flush();
1207   policy->RemoveExtensionData("deleteextensiondata");
1208
1209   CheckReadFilteredData(
1210       policy,
1211       "deleteextensiondata",
1212       Action::ACTION_ANY,
1213       "",
1214       "",
1215       "",
1216       -1,
1217       base::Bind(
1218           &CountingPolicyTest::RetrieveActions_FetchFilteredActions0));
1219
1220   CheckReadFilteredData(
1221       policy,
1222       "dontdelete",
1223       Action::ACTION_ANY,
1224       "",
1225       "",
1226       "",
1227       -1,
1228       base::Bind(
1229           &CountingPolicyTest::RetrieveActions_FetchFilteredActions1));
1230   policy->Close();
1231 }
1232
1233 TEST_F(CountingPolicyTest, DeleteDatabase) {
1234   CountingPolicy* policy = new CountingPolicy(profile_.get());
1235   policy->Init();
1236   // Disable row expiration for this test by setting a time before any actions
1237   // we generate.
1238   policy->set_retention_time(base::TimeDelta::FromDays(14));
1239
1240   // Use a mock clock to ensure that events are not recorded on the wrong day
1241   // when the test is run close to local midnight.  Note: Ownership is passed
1242   // to the policy, but we still keep a pointer locally.  The policy will take
1243   // care of destruction; this is safe since the policy outlives all our
1244   // accesses to the mock clock.
1245   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
1246   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
1247                      base::TimeDelta::FromHours(12));
1248   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
1249
1250   // Record some actions
1251   scoped_refptr<Action> action =
1252       new Action("punky",
1253                  mock_clock->Now() - base::TimeDelta::FromMinutes(40),
1254                  Action::ACTION_API_CALL,
1255                  "brewster");
1256   action->mutable_args()->AppendString("woof");
1257   policy->ProcessAction(action);
1258
1259   action = new Action("punky",
1260                       mock_clock->Now() - base::TimeDelta::FromMinutes(30),
1261                       Action::ACTION_API_CALL,
1262                       "brewster");
1263   action->mutable_args()->AppendString("meow");
1264   policy->ProcessAction(action);
1265
1266   action = new Action("punky",
1267                       mock_clock->Now() - base::TimeDelta::FromMinutes(20),
1268                       Action::ACTION_API_CALL,
1269                       "extension.sendMessage");
1270   action->mutable_args()->AppendString("not");
1271   action->mutable_args()->AppendString("stripped");
1272   policy->ProcessAction(action);
1273
1274   action =
1275       new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1276   action->mutable_args()->AppendString("vamoose");
1277   action->set_page_url(GURL("http://www.google.com"));
1278   policy->ProcessAction(action);
1279
1280   action = new Action(
1281       "scoobydoo", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1282   action->mutable_args()->AppendString("vamoose");
1283   action->set_page_url(GURL("http://www.google.com"));
1284   policy->ProcessAction(action);
1285
1286   CheckReadData(
1287       policy,
1288       "punky",
1289       0,
1290       base::Bind(&CountingPolicyTest::Arguments_GetTodaysActions));
1291
1292   policy->DeleteDatabase();
1293
1294   CheckReadFilteredData(
1295       policy,
1296       "",
1297       Action::ACTION_ANY,
1298       "",
1299       "",
1300       "",
1301       -1,
1302       base::Bind(
1303           &CountingPolicyTest::RetrieveActions_FetchFilteredActions0));
1304
1305   // The following code tests that the caches of url and string tables were
1306   // cleared by the deletion above.
1307   // https://code.google.com/p/chromium/issues/detail?id=341674.
1308   action =
1309     new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets");
1310   action->mutable_args()->AppendString("vamoose");
1311   action->set_page_url(GURL("http://www.google.com"));
1312   policy->ProcessAction(action);
1313
1314   CheckReadData(
1315       policy,
1316       "",
1317       -1,
1318       base::Bind(&CountingPolicyTest::Arguments_GetSinglesAction));
1319
1320   policy->DeleteDatabase();
1321
1322   CheckReadFilteredData(
1323       policy,
1324       "",
1325       Action::ACTION_ANY,
1326       "",
1327       "",
1328       "",
1329       -1,
1330       base::Bind(
1331           &CountingPolicyTest::RetrieveActions_FetchFilteredActions0));
1332
1333   policy->Close();
1334 }
1335
1336 // Tests that duplicate rows in the activity log database are handled properly
1337 // when updating counts.
1338 TEST_F(CountingPolicyTest, DuplicateRows) {
1339   CountingPolicy* policy = new CountingPolicy(profile_.get());
1340   policy->Init();
1341   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
1342   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
1343                      base::TimeDelta::FromHours(12));
1344   policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
1345
1346   // Record two actions with distinct URLs.
1347   scoped_refptr<Action> action;
1348   action = new Action(
1349       "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster");
1350   action->set_page_url(GURL("http://www.google.com"));
1351   policy->ProcessAction(action);
1352
1353   action = new Action(
1354       "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster");
1355   action->set_page_url(GURL("http://www.google.co.uk"));
1356   policy->ProcessAction(action);
1357
1358   // Manipulate the database to clear the URLs, so that we end up with
1359   // duplicate rows.
1360   std::vector<GURL> no_url_restrictions;
1361   policy->RemoveURLs(no_url_restrictions);
1362
1363   // Record one more action, with no URL.  This should increment the count on
1364   // one, and exactly one, of the existing rows.
1365   action = new Action(
1366       "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster");
1367   policy->ProcessAction(action);
1368
1369   CheckReadData(
1370       policy,
1371       "punky",
1372       0,
1373       base::Bind(&CountingPolicyTest::CheckDuplicates));
1374   policy->Close();
1375 }
1376
1377 TEST_F(CountingPolicyTest, RemoveActions) {
1378   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
1379   policy->Init();
1380
1381   std::vector<int64> action_ids;
1382
1383   CheckRemoveActions(
1384       policy, action_ids, base::Bind(&CountingPolicyTest::NoActionsDeleted));
1385
1386   action_ids.push_back(-1);
1387   action_ids.push_back(-10);
1388   action_ids.push_back(0);
1389   action_ids.push_back(5);
1390   action_ids.push_back(10);
1391   CheckRemoveActions(
1392       policy, action_ids, base::Bind(&CountingPolicyTest::NoActionsDeleted));
1393   action_ids.clear();
1394
1395   for (int i = 0; i < 50; i++) {
1396     action_ids.push_back(i + 3);
1397   }
1398   CheckRemoveActions(
1399       policy, action_ids, base::Bind(&CountingPolicyTest::NoActionsDeleted));
1400   action_ids.clear();
1401
1402   // CheckRemoveActions pushes two actions to the Activity Log database with IDs
1403   // 1 and 2.
1404   action_ids.push_back(1);
1405   action_ids.push_back(2);
1406   CheckRemoveActions(
1407       policy, action_ids, base::Bind(&CountingPolicyTest::AllActionsDeleted));
1408   action_ids.clear();
1409
1410   action_ids.push_back(1);
1411   CheckRemoveActions(
1412       policy, action_ids, base::Bind(&CountingPolicyTest::Action1Deleted));
1413   action_ids.clear();
1414
1415   action_ids.push_back(2);
1416   CheckRemoveActions(
1417       policy, action_ids, base::Bind(&CountingPolicyTest::Action2Deleted));
1418   action_ids.clear();
1419
1420   policy->Close();
1421 }
1422
1423 }  // namespace extensions