chrome/browser/rlz/rlz_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/rlz/rlz.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/time/time.h"
  10 #include "chrome/browser/autocomplete/autocomplete_controller.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/google/google_brand.h"
  13 #include "chrome/browser/omnibox/omnibox_log.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/installer/util/browser_distribution.h"
  16 #include "chrome/installer/util/google_update_constants.h"
  17 #include "components/metrics/proto/omnibox_event.pb.h"
  18 #include "content/public/browser/navigation_entry.h"
  19 #include "content/public/browser/notification_details.h"
  20 #include "content/public/browser/notification_service.h"
  21 #include "content/public/browser/notification_source.h"
  22 #include "rlz/test/rlz_test_helpers.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 #if defined(OS_WIN)
  26 #include "base/win/registry.h"
  27 #endif
  28
  29 using content::NavigationEntry;
  30 using testing::AssertionResult;
  31 using testing::AssertionSuccess;
  32 using testing::AssertionFailure;
  33
  34 #if defined(OS_WIN)
  35 using base::win::RegKey;
  36 #endif
  37
  38 namespace {
  39
  40 // Dummy RLZ string for the access points.
  41 const char kOmniboxRlzString[] = "test_omnibox";
  42 const char kHomepageRlzString[] = "test_homepage";
  43 const char kAppListRlzString[] = "test_applist";
  44 const char kNewOmniboxRlzString[] = "new_omnibox";
  45 const char kNewHomepageRlzString[] = "new_homepage";
  46 const char kNewAppListRlzString[] = "new_applist";
  47
  48 // Some helper macros to test it a string contains/does not contain a substring.
  49
  50 AssertionResult CmpHelperSTRC(const char* str_expression,
  51                               const char* substr_expression,
  52                               const char* str,
  53                               const char* substr) {
  54   if (NULL != strstr(str, substr)) {
  55     return AssertionSuccess();
  56   }
  57
  58   return AssertionFailure() << "Expected: (" << substr_expression << ") in ("
  59                             << str_expression << "), actual: '"
  60                             << substr << "' not in '" << str << "'";
  61 }
  62
  63 AssertionResult CmpHelperSTRNC(const char* str_expression,
  64                                const char* substr_expression,
  65                                const char* str,
  66                                const char* substr) {
  67   if (NULL == strstr(str, substr)) {
  68     return AssertionSuccess();
  69   }
  70
  71   return AssertionFailure() << "Expected: (" << substr_expression
  72                             << ") not in (" << str_expression << "), actual: '"
  73                             << substr << "' in '" << str << "'";
  74 }
  75
  76 #define EXPECT_STR_CONTAINS(str, substr) \
  77     EXPECT_PRED_FORMAT2(CmpHelperSTRC, str, substr)
  78
  79 #define EXPECT_STR_NOT_CONTAIN(str, substr) \
  80     EXPECT_PRED_FORMAT2(CmpHelperSTRNC, str, substr)
  81
  82 }  // namespace
  83
  84 // Test class for RLZ tracker. Makes some member functions public and
  85 // overrides others to make it easier to test.
  86 class TestRLZTracker : public RLZTracker {
  87  public:
  88   using RLZTracker::InitRlzDelayed;
  89   using RLZTracker::DelayedInit;
  90   using RLZTracker::Observe;
  91
  92   TestRLZTracker() : assume_not_ui_thread_(true) {
  93     set_tracker(this);
  94   }
  95
  96   virtual ~TestRLZTracker() {
  97     set_tracker(NULL);
  98   }
  99
 100   bool was_ping_sent_for_brand(const std::string& brand) const {
 101     return pinged_brands_.count(brand) > 0;
 102   }
 103
 104   void set_assume_not_ui_thread(bool assume_not_ui_thread) {
 105     assume_not_ui_thread_ = assume_not_ui_thread;
 106   }
 107
 108  private:
 109   virtual void ScheduleDelayedInit(base::TimeDelta delay) OVERRIDE {
 110     // If the delay is 0, invoke the delayed init now. Otherwise,
 111     // don't schedule anything, it will be manually called during tests.
 112     if (delay == base::TimeDelta())
 113       DelayedInit();
 114   }
 115
 116   virtual void ScheduleFinancialPing() OVERRIDE {
 117     PingNowImpl();
 118   }
 119
 120   virtual bool ScheduleRecordProductEvent(rlz_lib::Product product,
 121                                           rlz_lib::AccessPoint point,
 122                                           rlz_lib::Event event_id) OVERRIDE {
 123     return !assume_not_ui_thread_;
 124   }
 125
 126   virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) OVERRIDE {
 127     return !assume_not_ui_thread_;
 128   }
 129
 130   virtual bool ScheduleRecordFirstSearch(rlz_lib::AccessPoint point) OVERRIDE {
 131     return !assume_not_ui_thread_;
 132   }
 133
 134 #if defined(OS_CHROMEOS)
 135   virtual bool ScheduleClearRlzState() OVERRIDE {
 136     return !assume_not_ui_thread_;
 137   }
 138 #endif
 139
 140   virtual bool SendFinancialPing(const std::string& brand,
 141                                  const base::string16& lang,
 142                                  const base::string16& referral) OVERRIDE {
 143     // Don't ping the server during tests, just pretend as if we did.
 144     EXPECT_FALSE(brand.empty());
 145     pinged_brands_.insert(brand);
 146
 147     // Set new access points RLZ string, like the actual server ping would have
 148     // done.
 149     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(),
 150                                kNewOmniboxRlzString);
 151     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeHomePage(),
 152                                kNewHomepageRlzString);
 153     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeAppList(),
 154                                kNewAppListRlzString);
 155     return true;
 156   }
 157
 158   std::set<std::string> pinged_brands_;
 159   bool assume_not_ui_thread_;
 160
 161   DISALLOW_COPY_AND_ASSIGN(TestRLZTracker);
 162 };
 163
 164 class RlzLibTest : public RlzLibTestNoMachineState {
 165  protected:
 166   virtual void SetUp() OVERRIDE;
 167
 168   void SetMainBrand(const char* brand);
 169   void SetReactivationBrand(const char* brand);
 170 #if defined(OS_WIN)
 171   void SetRegistryBrandValue(const wchar_t* name, const char* brand);
 172 #endif
 173
 174   void SimulateOmniboxUsage();
 175   void SimulateHomepageUsage();
 176   void SimulateAppListUsage();
 177   void InvokeDelayedInit();
 178
 179   void ExpectEventRecorded(const char* event_name, bool expected);
 180   void ExpectRlzPingSent(bool expected);
 181   void ExpectReactivationRlzPingSent(bool expected);
 182
 183   TestRLZTracker tracker_;
 184 #if defined(OS_POSIX)
 185   scoped_ptr<google_brand::BrandForTesting> brand_override_;
 186 #endif
 187 };
 188
 189 void RlzLibTest::SetUp() {
 190   RlzLibTestNoMachineState::SetUp();
 191
 192   // Make sure a non-organic brand code is set in the registry or the RLZTracker
 193   // is pretty much a no-op.
 194   SetMainBrand("TEST");
 195   SetReactivationBrand("");
 196 }
 197
 198 void RlzLibTest::SetMainBrand(const char* brand) {
 199 #if defined(OS_WIN)
 200   SetRegistryBrandValue(google_update::kRegRLZBrandField, brand);
 201 #elif defined(OS_POSIX)
 202   brand_override_.reset(new google_brand::BrandForTesting(brand));
 203 #endif
 204   std::string check_brand;
 205   google_brand::GetBrand(&check_brand);
 206   EXPECT_EQ(brand, check_brand);
 207 }
 208
 209 void RlzLibTest::SetReactivationBrand(const char* brand) {
 210   // TODO(thakis): Reactivation doesn't exist on Mac yet.
 211 #if defined(OS_WIN)
 212   SetRegistryBrandValue(google_update::kRegRLZReactivationBrandField, brand);
 213   std::string check_brand;
 214   google_brand::GetReactivationBrand(&check_brand);
 215   EXPECT_EQ(brand, check_brand);
 216 #endif
 217 }
 218
 219 #if defined(OS_WIN)
 220 void RlzLibTest::SetRegistryBrandValue(const wchar_t* name,
 221                                        const char* brand) {
 222   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 223   base::string16 reg_path = dist->GetStateKey();
 224   RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_SET_VALUE);
 225   if (*brand == 0) {
 226     LONG result = key.DeleteValue(name);
 227     ASSERT_TRUE(ERROR_SUCCESS == result || ERROR_FILE_NOT_FOUND == result);
 228   } else {
 229     base::string16 brand16 = base::ASCIIToUTF16(brand);
 230     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name, brand16.c_str()));
 231   }
 232 }
 233 #endif
 234
 235 void RlzLibTest::SimulateOmniboxUsage() {
 236   // Create a dummy OmniboxLog object. The 'is_popup_open' field needs to be
 237   // true to trigger record of the first search. All other fields are passed in
 238   // with empty or invalid values.
 239   AutocompleteResult empty_result;
 240   OmniboxLog dummy(base::string16(), false, metrics::OmniboxInputType::INVALID,
 241                    true, 0, false, -1,
 242                    metrics::OmniboxEventProto::INVALID_SPEC,
 243                    base::TimeDelta::FromSeconds(0), 0,
 244                    base::TimeDelta::FromSeconds(0),
 245                    AutocompleteResult());
 246
 247   tracker_.Observe(chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
 248                    content::NotificationService::AllSources(),
 249                    content::Details<OmniboxLog>(&dummy));
 250 }
 251
 252 void RlzLibTest::SimulateHomepageUsage() {
 253   scoped_ptr<NavigationEntry> entry(NavigationEntry::Create());
 254   entry->SetPageID(0);
 255   entry->SetTransitionType(content::PAGE_TRANSITION_HOME_PAGE);
 256   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
 257                    content::NotificationService::AllSources(),
 258                    content::Details<NavigationEntry>(entry.get()));
 259 }
 260
 261 void RlzLibTest::SimulateAppListUsage() {
 262   RLZTracker::RecordAppListSearch();
 263 }
 264
 265 void RlzLibTest::InvokeDelayedInit() {
 266   tracker_.DelayedInit();
 267 }
 268
 269 void RlzLibTest::ExpectEventRecorded(const char* event_name, bool expected) {
 270   char cgi[rlz_lib::kMaxCgiLength];
 271   GetProductEventsAsCgi(rlz_lib::CHROME, cgi, arraysize(cgi));
 272   if (expected) {
 273     EXPECT_STR_CONTAINS(cgi, event_name);
 274   } else {
 275     EXPECT_STR_NOT_CONTAIN(cgi, event_name);
 276   }
 277 }
 278
 279 void RlzLibTest::ExpectRlzPingSent(bool expected) {
 280   std::string brand;
 281   google_brand::GetBrand(&brand);
 282   EXPECT_EQ(expected, tracker_.was_ping_sent_for_brand(brand.c_str()));
 283 }
 284
 285 void RlzLibTest::ExpectReactivationRlzPingSent(bool expected) {
 286   std::string brand;
 287   google_brand::GetReactivationBrand(&brand);
 288   EXPECT_EQ(expected, tracker_.was_ping_sent_for_brand(brand.c_str()));
 289 }
 290
 291 // The events that affect the different RLZ scenarios are the following:
 292 //
 293 //  A: the user starts chrome for the first time
 294 //  B: the user stops chrome
 295 //  C: the user start a subsequent time
 296 //  D: the user stops chrome again
 297 //  I: the RLZTracker::DelayedInit() method is invoked
 298 //  X: the user performs a search using the omnibox
 299 //  Y: the user performs a search using the home page
 300 //  Z: the user performs a search using the app list
 301 //
 302 // The events A to D happen in chronological order, but the other events
 303 // may happen at any point between A-B or C-D, in no particular order.
 304 //
 305 // The visible results of the scenarios on Win are:
 306 //
 307 //  C1I event is recorded
 308 //  C2I event is recorded
 309 //  C7I event is recorded
 310 //  C1F event is recorded
 311 //  C2F event is recorded
 312 //  C7F event is recorded
 313 //  C1S event is recorded
 314 //  C2S event is recorded
 315 //  C7S event is recorded
 316 //  RLZ ping sent
 317 //
 318 //  On Mac, C5 / C6 / C8 are sent instead of C1 / C2 / C7.
 319 //  On ChromeOS, CA / CB / CC are sent, respectively.
 320 //
 321 // Variations on the above scenarios:
 322 //
 323 //  - if the delay specified to InitRlzDelayed() is negative, then the RLZ
 324 //    ping should be sent out at the time of event X and not wait for I
 325 //
 326 // Also want to test that pre-warming the RLZ string cache works correctly.
 327
 328 #if defined(OS_WIN)
 329 const char kOmniboxInstall[] = "C1I";
 330 const char kOmniboxSetToGoogle[] = "C1S";
 331 const char kOmniboxFirstSearch[] = "C1F";
 332
 333 const char kHomepageInstall[] = "C2I";
 334 const char kHomepageSetToGoogle[] = "C2S";
 335 const char kHomepageFirstSeach[] = "C2F";
 336
 337 const char kAppListInstall[] = "C7I";
 338 const char kAppListSetToGoogle[] = "C7S";
 339 const char kAppListFirstSearch[] = "C7F";
 340 #elif defined(OS_MACOSX)
 341 const char kOmniboxInstall[] = "C5I";
 342 const char kOmniboxSetToGoogle[] = "C5S";
 343 const char kOmniboxFirstSearch[] = "C5F";
 344
 345 const char kHomepageInstall[] = "C6I";
 346 const char kHomepageSetToGoogle[] = "C6S";
 347 const char kHomepageFirstSeach[] = "C6F";
 348
 349 const char kAppListInstall[] = "C8I";
 350 const char kAppListSetToGoogle[] = "C8S";
 351 const char kAppListFirstSearch[] = "C8F";
 352 #elif defined(OS_CHROMEOS)
 353 const char kOmniboxInstall[] = "CAI";
 354 const char kOmniboxSetToGoogle[] = "CAS";
 355 const char kOmniboxFirstSearch[] = "CAF";
 356
 357 const char kHomepageInstall[] = "CBI";
 358 const char kHomepageSetToGoogle[] = "CBS";
 359 const char kHomepageFirstSeach[] = "CBF";
 360
 361 const char kAppListInstall[] = "CCI";
 362 const char kAppListSetToGoogle[] = "CCS";
 363 const char kAppListFirstSearch[] = "CCF";
 364 #endif
 365
 366 const base::TimeDelta kDelay = base::TimeDelta::FromMilliseconds(20);
 367
 368 TEST_F(RlzLibTest, RecordProductEvent) {
 369   RLZTracker::RecordProductEvent(rlz_lib::CHROME, RLZTracker::ChromeOmnibox(),
 370                                  rlz_lib::FIRST_SEARCH);
 371
 372   ExpectEventRecorded(kOmniboxFirstSearch, true);
 373 }
 374
 375 TEST_F(RlzLibTest, QuickStopAfterStart) {
 376   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, true);
 377
 378   // Omnibox events.
 379   ExpectEventRecorded(kOmniboxInstall, false);
 380   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 381   ExpectEventRecorded(kOmniboxFirstSearch, false);
 382
 383   // Home page events.
 384   ExpectEventRecorded(kHomepageInstall, false);
 385   ExpectEventRecorded(kHomepageSetToGoogle, false);
 386   ExpectEventRecorded(kHomepageFirstSeach, false);
 387
 388   // App list events.
 389   ExpectEventRecorded(kAppListInstall, false);
 390   ExpectEventRecorded(kAppListSetToGoogle, false);
 391   ExpectEventRecorded(kAppListFirstSearch, false);
 392
 393   ExpectRlzPingSent(false);
 394 }
 395
 396 TEST_F(RlzLibTest, DelayedInitOnly) {
 397   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 398   InvokeDelayedInit();
 399
 400   // Omnibox events.
 401   ExpectEventRecorded(kOmniboxInstall, true);
 402   ExpectEventRecorded(kOmniboxSetToGoogle, true);
 403   ExpectEventRecorded(kOmniboxFirstSearch, false);
 404
 405   // Home page events.
 406   ExpectEventRecorded(kHomepageInstall, true);
 407   ExpectEventRecorded(kHomepageSetToGoogle, true);
 408   ExpectEventRecorded(kHomepageFirstSeach, false);
 409
 410   // App list events.
 411   ExpectEventRecorded(kAppListInstall, true);
 412   ExpectEventRecorded(kAppListSetToGoogle, true);
 413   ExpectEventRecorded(kAppListFirstSearch, false);
 414
 415   ExpectRlzPingSent(true);
 416 }
 417
 418 TEST_F(RlzLibTest, DelayedInitOnlyGoogleAsStartup) {
 419   TestRLZTracker::InitRlzDelayed(true, false, kDelay, false, false, true);
 420   InvokeDelayedInit();
 421
 422   // Omnibox events.
 423   ExpectEventRecorded(kOmniboxInstall, true);
 424   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 425   ExpectEventRecorded(kOmniboxFirstSearch, false);
 426
 427   // Home page events.
 428   ExpectEventRecorded(kHomepageInstall, true);
 429   ExpectEventRecorded(kHomepageSetToGoogle, true);
 430   ExpectEventRecorded(kHomepageFirstSeach, true);
 431
 432   // App list events.
 433   ExpectEventRecorded(kAppListInstall, true);
 434   ExpectEventRecorded(kAppListSetToGoogle, false);
 435   ExpectEventRecorded(kAppListFirstSearch, false);
 436
 437   ExpectRlzPingSent(true);
 438 }
 439
 440 TEST_F(RlzLibTest, DelayedInitOnlyNoFirstRunNoRlzStrings) {
 441   TestRLZTracker::InitRlzDelayed(false, false, kDelay, true, true, false);
 442   InvokeDelayedInit();
 443
 444   // Omnibox events.
 445   ExpectEventRecorded(kOmniboxInstall, true);
 446   ExpectEventRecorded(kOmniboxSetToGoogle, true);
 447   ExpectEventRecorded(kOmniboxFirstSearch, false);
 448
 449   // Home page events.
 450   ExpectEventRecorded(kHomepageInstall, true);
 451   ExpectEventRecorded(kHomepageSetToGoogle, true);
 452   ExpectEventRecorded(kHomepageFirstSeach, false);
 453
 454   // App list events.
 455   ExpectEventRecorded(kAppListInstall, true);
 456   ExpectEventRecorded(kAppListSetToGoogle, true);
 457   ExpectEventRecorded(kAppListFirstSearch, false);
 458
 459   ExpectRlzPingSent(true);
 460 }
 461
 462 TEST_F(RlzLibTest, DelayedInitOnlyNoFirstRunNoRlzStringsGoogleAsStartup) {
 463   TestRLZTracker::InitRlzDelayed(false, false, kDelay, false, false, true);
 464   InvokeDelayedInit();
 465
 466   // Omnibox events.
 467   ExpectEventRecorded(kOmniboxInstall, true);
 468   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 469   ExpectEventRecorded(kOmniboxFirstSearch, false);
 470
 471   // Home page events.
 472   ExpectEventRecorded(kHomepageInstall, true);
 473   ExpectEventRecorded(kHomepageSetToGoogle, true);
 474   ExpectEventRecorded(kHomepageFirstSeach, true);
 475
 476   // App list events.
 477   ExpectEventRecorded(kAppListInstall, true);
 478   ExpectEventRecorded(kAppListSetToGoogle, false);
 479   ExpectEventRecorded(kAppListFirstSearch, false);
 480
 481   ExpectRlzPingSent(true);
 482 }
 483
 484 TEST_F(RlzLibTest, DelayedInitOnlyNoFirstRun) {
 485   // Set some dummy RLZ strings to simulate that we already ran before and
 486   // performed a successful ping to the RLZ server.
 487   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(), kOmniboxRlzString);
 488   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeHomePage(), kHomepageRlzString);
 489   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeAppList(), kAppListRlzString);
 490
 491   TestRLZTracker::InitRlzDelayed(false, false, kDelay, true, true, true);
 492   InvokeDelayedInit();
 493
 494   // Omnibox events.
 495   ExpectEventRecorded(kOmniboxInstall, true);
 496   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 497   ExpectEventRecorded(kOmniboxFirstSearch, false);
 498
 499   // Home page events.
 500   ExpectEventRecorded(kHomepageInstall, true);
 501   ExpectEventRecorded(kHomepageSetToGoogle, false);
 502   ExpectEventRecorded(kHomepageFirstSeach, true);
 503
 504   // App list events.
 505   ExpectEventRecorded(kAppListInstall, true);
 506   ExpectEventRecorded(kAppListSetToGoogle, false);
 507   ExpectEventRecorded(kAppListFirstSearch, false);
 508
 509   ExpectRlzPingSent(true);
 510 }
 511
 512 TEST_F(RlzLibTest, DelayedInitOnlyNoGoogleDefaultSearchOrHomepageOrStartup) {
 513   TestRLZTracker::InitRlzDelayed(true, false, kDelay, false, false, false);
 514   InvokeDelayedInit();
 515
 516   // Omnibox events.
 517   ExpectEventRecorded(kOmniboxInstall, true);
 518   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 519   ExpectEventRecorded(kOmniboxFirstSearch, false);
 520
 521   // Home page events.
 522   ExpectEventRecorded(kHomepageInstall, true);
 523   ExpectEventRecorded(kHomepageSetToGoogle, false);
 524   ExpectEventRecorded(kHomepageFirstSeach, false);
 525
 526   // App list events.
 527   ExpectEventRecorded(kAppListInstall, true);
 528   ExpectEventRecorded(kAppListSetToGoogle, false);
 529   ExpectEventRecorded(kAppListFirstSearch, false);
 530
 531   ExpectRlzPingSent(true);
 532 }
 533
 534 TEST_F(RlzLibTest, OmniboxUsageOnly) {
 535   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 536   SimulateOmniboxUsage();
 537
 538   // Omnibox events.
 539   ExpectEventRecorded(kOmniboxInstall, false);
 540   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 541   ExpectEventRecorded(kOmniboxFirstSearch, true);
 542
 543   // Home page events.
 544   ExpectEventRecorded(kHomepageInstall, false);
 545   ExpectEventRecorded(kHomepageSetToGoogle, false);
 546   ExpectEventRecorded(kHomepageFirstSeach, false);
 547
 548   // App list events.
 549   ExpectEventRecorded(kAppListInstall, false);
 550   ExpectEventRecorded(kAppListSetToGoogle, false);
 551   ExpectEventRecorded(kAppListFirstSearch, false);
 552
 553   ExpectRlzPingSent(false);
 554 }
 555
 556 TEST_F(RlzLibTest, HomepageUsageOnly) {
 557   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 558   SimulateHomepageUsage();
 559
 560   // Omnibox events.
 561   ExpectEventRecorded(kOmniboxInstall, false);
 562   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 563   ExpectEventRecorded(kOmniboxFirstSearch, false);
 564
 565   // Home page events.
 566   ExpectEventRecorded(kHomepageInstall, false);
 567   ExpectEventRecorded(kHomepageSetToGoogle, false);
 568   ExpectEventRecorded(kHomepageFirstSeach, true);
 569
 570   // App list events.
 571   ExpectEventRecorded(kAppListInstall, false);
 572   ExpectEventRecorded(kAppListSetToGoogle, false);
 573   ExpectEventRecorded(kAppListFirstSearch, false);
 574
 575   ExpectRlzPingSent(false);
 576 }
 577
 578 TEST_F(RlzLibTest, AppListUsageOnly) {
 579   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 580   SimulateAppListUsage();
 581
 582   // Omnibox events.
 583   ExpectEventRecorded(kOmniboxInstall, false);
 584   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 585   ExpectEventRecorded(kOmniboxFirstSearch, false);
 586
 587   // Home page events.
 588   ExpectEventRecorded(kHomepageInstall, false);
 589   ExpectEventRecorded(kHomepageSetToGoogle, false);
 590   ExpectEventRecorded(kHomepageFirstSeach, false);
 591
 592   // App list events.
 593   ExpectEventRecorded(kAppListInstall, false);
 594   ExpectEventRecorded(kAppListSetToGoogle, false);
 595   ExpectEventRecorded(kAppListFirstSearch, true);
 596
 597   ExpectRlzPingSent(false);
 598 }
 599
 600 TEST_F(RlzLibTest, UsageBeforeDelayedInit) {
 601   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 602   SimulateOmniboxUsage();
 603   SimulateHomepageUsage();
 604   SimulateAppListUsage();
 605   InvokeDelayedInit();
 606
 607   // Omnibox events.
 608   ExpectEventRecorded(kOmniboxInstall, true);
 609   ExpectEventRecorded(kOmniboxSetToGoogle, true);
 610   ExpectEventRecorded(kOmniboxFirstSearch, true);
 611
 612   // Home page events.
 613   ExpectEventRecorded(kHomepageInstall, true);
 614   ExpectEventRecorded(kHomepageSetToGoogle, true);
 615   ExpectEventRecorded(kHomepageFirstSeach, true);
 616
 617   // App list events.
 618   ExpectEventRecorded(kAppListInstall, true);
 619   ExpectEventRecorded(kAppListSetToGoogle, true);
 620   ExpectEventRecorded(kAppListFirstSearch, true);
 621
 622   ExpectRlzPingSent(true);
 623 }
 624
 625 TEST_F(RlzLibTest, UsageAfterDelayedInit) {
 626   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 627   InvokeDelayedInit();
 628   SimulateOmniboxUsage();
 629   SimulateHomepageUsage();
 630   SimulateAppListUsage();
 631
 632   // Omnibox events.
 633   ExpectEventRecorded(kOmniboxInstall, true);
 634   ExpectEventRecorded(kOmniboxSetToGoogle, true);
 635   ExpectEventRecorded(kOmniboxFirstSearch, true);
 636
 637   // Home page events.
 638   ExpectEventRecorded(kHomepageInstall, true);
 639   ExpectEventRecorded(kHomepageSetToGoogle, true);
 640   ExpectEventRecorded(kHomepageFirstSeach, true);
 641
 642   // App list events.
 643   ExpectEventRecorded(kAppListInstall, true);
 644   ExpectEventRecorded(kAppListSetToGoogle, true);
 645   ExpectEventRecorded(kAppListFirstSearch, true);
 646
 647   ExpectRlzPingSent(true);
 648 }
 649
 650 TEST_F(RlzLibTest, OmniboxUsageSendsPingWhenSendPingImmediately) {
 651   TestRLZTracker::InitRlzDelayed(true, true, kDelay, true, true, false);
 652   SimulateOmniboxUsage();
 653
 654   // Omnibox events.
 655   ExpectEventRecorded(kOmniboxInstall, true);
 656   ExpectEventRecorded(kOmniboxSetToGoogle, true);
 657   ExpectEventRecorded(kOmniboxFirstSearch, true);
 658
 659   // Home page events.
 660   ExpectEventRecorded(kHomepageInstall, true);
 661   ExpectEventRecorded(kHomepageSetToGoogle, true);
 662   ExpectEventRecorded(kHomepageFirstSeach, false);
 663
 664   // App list events.
 665   ExpectEventRecorded(kAppListInstall, true);
 666   ExpectEventRecorded(kAppListSetToGoogle, true);
 667   ExpectEventRecorded(kAppListFirstSearch, false);
 668
 669   ExpectRlzPingSent(true);
 670 }
 671
 672 TEST_F(RlzLibTest, HomepageUsageDoesNotSendPingWhenSendPingImmediately) {
 673   TestRLZTracker::InitRlzDelayed(true, true, kDelay, true, true, false);
 674   SimulateHomepageUsage();
 675
 676   // Omnibox events.
 677   ExpectEventRecorded(kOmniboxInstall, false);
 678   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 679   ExpectEventRecorded(kOmniboxFirstSearch, false);
 680
 681   // Home page events.
 682   ExpectEventRecorded(kHomepageInstall, false);
 683   ExpectEventRecorded(kHomepageSetToGoogle, false);
 684   ExpectEventRecorded(kHomepageFirstSeach, true);
 685
 686   // App list events.
 687   ExpectEventRecorded(kAppListInstall, false);
 688   ExpectEventRecorded(kAppListSetToGoogle, false);
 689   ExpectEventRecorded(kAppListFirstSearch, false);
 690
 691   ExpectRlzPingSent(false);
 692 }
 693
 694 TEST_F(RlzLibTest, StartupUsageDoesNotSendPingWhenSendPingImmediately) {
 695   TestRLZTracker::InitRlzDelayed(true, true, kDelay, true, false, true);
 696   SimulateHomepageUsage();
 697
 698   // Omnibox events.
 699   ExpectEventRecorded(kOmniboxInstall, false);
 700   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 701   ExpectEventRecorded(kOmniboxFirstSearch, false);
 702
 703   // Home page events.
 704   ExpectEventRecorded(kHomepageInstall, false);
 705   ExpectEventRecorded(kHomepageSetToGoogle, false);
 706   ExpectEventRecorded(kHomepageFirstSeach, true);
 707
 708   // App list events.
 709   ExpectEventRecorded(kAppListInstall, false);
 710   ExpectEventRecorded(kAppListSetToGoogle, false);
 711   ExpectEventRecorded(kAppListFirstSearch, false);
 712
 713   ExpectRlzPingSent(false);
 714 }
 715
 716 TEST_F(RlzLibTest, AppListUsageDoesNotSendPingWhenSendPingImmediately) {
 717   TestRLZTracker::InitRlzDelayed(true, true, kDelay, true, false, false);
 718   SimulateAppListUsage();
 719
 720   // Omnibox events.
 721   ExpectEventRecorded(kOmniboxInstall, false);
 722   ExpectEventRecorded(kOmniboxSetToGoogle, false);
 723   ExpectEventRecorded(kOmniboxFirstSearch, false);
 724
 725   // Home page events.
 726   ExpectEventRecorded(kHomepageInstall, false);
 727   ExpectEventRecorded(kHomepageSetToGoogle, false);
 728   ExpectEventRecorded(kHomepageFirstSeach, false);
 729
 730   // App list events.
 731   ExpectEventRecorded(kAppListInstall, false);
 732   ExpectEventRecorded(kAppListSetToGoogle, false);
 733   ExpectEventRecorded(kAppListFirstSearch, true);
 734
 735   ExpectRlzPingSent(false);
 736 }
 737
 738 TEST_F(RlzLibTest, GetAccessPointRlzOnIoThread) {
 739   // Set dummy RLZ string.
 740   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(), kOmniboxRlzString);
 741
 742   base::string16 rlz;
 743
 744   tracker_.set_assume_not_ui_thread(true);
 745   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 746   EXPECT_STREQ(kOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
 747 }
 748
 749 TEST_F(RlzLibTest, GetAccessPointRlzNotOnIoThread) {
 750   // Set dummy RLZ string.
 751   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(), kOmniboxRlzString);
 752
 753   base::string16 rlz;
 754
 755   tracker_.set_assume_not_ui_thread(false);
 756   EXPECT_FALSE(
 757       RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 758 }
 759
 760 TEST_F(RlzLibTest, GetAccessPointRlzIsCached) {
 761   // Set dummy RLZ string.
 762   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(), kOmniboxRlzString);
 763
 764   base::string16 rlz;
 765
 766   tracker_.set_assume_not_ui_thread(false);
 767   EXPECT_FALSE(
 768       RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 769
 770   tracker_.set_assume_not_ui_thread(true);
 771   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 772   EXPECT_STREQ(kOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
 773
 774   tracker_.set_assume_not_ui_thread(false);
 775   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 776   EXPECT_STREQ(kOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
 777 }
 778
 779 TEST_F(RlzLibTest, PingUpdatesRlzCache) {
 780   // Set dummy RLZ string.
 781   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeOmnibox(), kOmniboxRlzString);
 782   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeHomePage(), kHomepageRlzString);
 783   rlz_lib::SetAccessPointRlz(RLZTracker::ChromeAppList(), kAppListRlzString);
 784
 785   base::string16 rlz;
 786
 787   // Prime the cache.
 788   tracker_.set_assume_not_ui_thread(true);
 789
 790   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 791   EXPECT_STREQ(kOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
 792   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(
 793         RLZTracker::ChromeHomePage(), &rlz));
 794   EXPECT_STREQ(kHomepageRlzString, base::UTF16ToUTF8(rlz).c_str());
 795   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeAppList(), &rlz));
 796   EXPECT_STREQ(kAppListRlzString, base::UTF16ToUTF8(rlz).c_str());
 797
 798   // Make sure cache is valid.
 799   tracker_.set_assume_not_ui_thread(false);
 800
 801   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 802   EXPECT_STREQ(kOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
 803   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(
 804         RLZTracker::ChromeHomePage(), &rlz));
 805   EXPECT_STREQ(kHomepageRlzString, base::UTF16ToUTF8(rlz).c_str());
 806   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeAppList(), &rlz));
 807   EXPECT_STREQ(kAppListRlzString, base::UTF16ToUTF8(rlz).c_str());
 808
 809   // Perform ping.
 810   tracker_.set_assume_not_ui_thread(true);
 811   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 812   InvokeDelayedInit();
 813   ExpectRlzPingSent(true);
 814
 815   // Make sure cache is now updated.
 816   tracker_.set_assume_not_ui_thread(false);
 817
 818   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
 819   EXPECT_STREQ(kNewOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
 820   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(
 821         RLZTracker::ChromeHomePage(), &rlz));
 822   EXPECT_STREQ(kNewHomepageRlzString, base::UTF16ToUTF8(rlz).c_str());
 823   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeAppList(), &rlz));
 824   EXPECT_STREQ(kNewAppListRlzString, base::UTF16ToUTF8(rlz).c_str());
 825 }
 826
 827 TEST_F(RlzLibTest, ObserveHandlesBadArgs) {
 828   scoped_ptr<NavigationEntry> entry(NavigationEntry::Create());
 829   entry->SetPageID(0);
 830   entry->SetTransitionType(content::PAGE_TRANSITION_LINK);
 831   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
 832                    content::NotificationService::AllSources(),
 833                    content::Details<NavigationEntry>(NULL));
 834   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
 835                    content::NotificationService::AllSources(),
 836                    content::Details<NavigationEntry>(entry.get()));
 837 }
 838
 839 // TODO(thakis): Reactivation doesn't exist on Mac yet.
 840 #if defined(OS_WIN)
 841 TEST_F(RlzLibTest, ReactivationNonOrganicNonOrganic) {
 842   SetReactivationBrand("REAC");
 843
 844   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 845   InvokeDelayedInit();
 846
 847   ExpectRlzPingSent(true);
 848   ExpectReactivationRlzPingSent(true);
 849 }
 850
 851 TEST_F(RlzLibTest, ReactivationOrganicNonOrganic) {
 852   SetMainBrand("GGLS");
 853   SetReactivationBrand("REAC");
 854
 855   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 856   InvokeDelayedInit();
 857
 858   ExpectRlzPingSent(false);
 859   ExpectReactivationRlzPingSent(true);
 860 }
 861
 862 TEST_F(RlzLibTest, ReactivationNonOrganicOrganic) {
 863   SetMainBrand("TEST");
 864   SetReactivationBrand("GGLS");
 865
 866   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 867   InvokeDelayedInit();
 868
 869   ExpectRlzPingSent(true);
 870   ExpectReactivationRlzPingSent(false);
 871 }
 872
 873 TEST_F(RlzLibTest, ReactivationOrganicOrganic) {
 874   SetMainBrand("GGLS");
 875   SetReactivationBrand("GGRS");
 876
 877   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
 878   InvokeDelayedInit();
 879
 880   ExpectRlzPingSent(false);
 881   ExpectReactivationRlzPingSent(false);
 882 }
 883 #endif  // defined(OS_WIN)
 884
 885 #if defined(OS_CHROMEOS)
 886 TEST_F(RlzLibTest, ClearRlzState) {
 887   RLZTracker::RecordProductEvent(rlz_lib::CHROME, RLZTracker::ChromeOmnibox(),
 888                                  rlz_lib::FIRST_SEARCH);
 889
 890   ExpectEventRecorded(kOmniboxFirstSearch, true);
 891
 892   RLZTracker::ClearRlzState();
 893
 894   ExpectEventRecorded(kOmniboxFirstSearch, false);
 895 }
 896 #endif  // defined(OS_CHROMEOS)