After a successful ping of the RLZ server, make sure to update the cached

chrome/browser/rlz/rlz_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/rlz/rlz.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/path_service.h"
 #include "base/test/test_reg_util_win.h"
@@ skipping 19 matching lines @@
 
 namespace {
 
 // Registry path to overridden hive.
 const wchar_t kRlzTempHkcu[] = L"rlz_hkcu";
 const wchar_t kRlzTempHklm[] = L"rlz_hklm";
 
 // Dummy RLZ string for the access points.
 const char kOmniboxRlzString[] = "test_omnibox";
 const char kHomepageRlzString[] = "test_homepage";
+const char kNewOmniboxRlzString[] = "new_omnibox";
+const char kNewHomepageRlzString[] = "new_homepage";
 
 // Some helper macros to test it a string contains/does not contain a substring.
 
 AssertionResult CmpHelperSTRC(const char* str_expression,
                               const char* substr_expression,
                               const char* str,
                               const char* substr) {
   if (NULL != strstr(str, substr)) {
     return AssertionSuccess();
   }
@@ skipping 24 matching lines @@
 
 }  // namespace
 
 // Test class for RLZ tracker. Makes some member functions public and
 // overrides others to make it easier to test.
 class TestRLZTracker : public RLZTracker {
  public:
   using RLZTracker::DelayedInit;
   using RLZTracker::Observe;
 
-  TestRLZTracker() : pingnow_called_(false), assume_io_thread_(false) {
+  TestRLZTracker() : pingnow_called_(false), assume_not_ui_thread_(false) {
     set_tracker(this);
   }
 
   virtual ~TestRLZTracker() {
     set_tracker(NULL);
   }
 
   bool pingnow_called() const {
     return pingnow_called_;
   }
 
-  bool assume_io_thread() const {
-    return assume_io_thread_;
-  }
-
-  void set_assume_io_thread(bool assume_io_thread) {
-    assume_io_thread_ = assume_io_thread;
+  void set_assume_not_ui_thread(bool assume_not_ui_thread) {
+    assume_not_ui_thread_ = assume_not_ui_thread;
   }
 
  private:
   virtual void ScheduleDelayedInit(int delay) OVERRIDE {
     // If the delay is 0, invoke the delayed init now. Otherwise,
     // don't schedule anything, it will be manually called during tests.
     if (delay == 0)
       DelayedInit();
   }
 
   virtual void ScheduleFinancialPing() OVERRIDE {
     PingNow(this);
   }
 
   virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) OVERRIDE {
-    return !assume_io_thread_;
+    return !assume_not_ui_thread_;
   }
 
   virtual bool SendFinancialPing(const std::wstring& brand,
                                  const std::wstring& lang,
                                  const std::wstring& referral,
                                  bool exclude_id) OVERRIDE {
     // Don't ping the server during tests.
     pingnow_called_ = true;
+
+    // Set new access points RLZ string, like the actual server ping would have
+    // done.
+    rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kNewOmniboxRlzString);
+    rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE,
+                               kNewHomepageRlzString);
     return true;
   }
 
   bool pingnow_called_;
-  bool assume_io_thread_;
+  bool assume_not_ui_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRLZTracker);
 };
 
 class RlzLibTest : public testing::Test {
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
  protected:
   void SimulateOmniboxUsage();
@@ skipping 317 matching lines @@
 
   ExpectRlzPingSent(false);
 }
 
 TEST_F(RlzLibTest, GetAccessPointRlzOnIoThread) {
   // Set dummy RLZ string.
   rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kOmniboxRlzString);
 
   std::wstring rlz;
 
-  tracker_.set_assume_io_thread(true);
+  tracker_.set_assume_not_ui_thread(true);
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
   EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
 }
 
 TEST_F(RlzLibTest, GetAccessPointRlzNotOnIoThread) {
   // Set dummy RLZ string.
   rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kOmniboxRlzString);
 
   std::wstring rlz;
 
-  tracker_.set_assume_io_thread(false);
+  tracker_.set_assume_not_ui_thread(false);
   EXPECT_FALSE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
 }
 
 TEST_F(RlzLibTest, GetAccessPointRlzIsCached) {
   // Set dummy RLZ string.
   rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kOmniboxRlzString);
 
   std::wstring rlz;
 
-  tracker_.set_assume_io_thread(false);
+  tracker_.set_assume_not_ui_thread(false);
   EXPECT_FALSE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
 
-  tracker_.set_assume_io_thread(true);
+  tracker_.set_assume_not_ui_thread(true);
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
   EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
 
-  tracker_.set_assume_io_thread(false);
+  tracker_.set_assume_not_ui_thread(false);
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
   EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
 }
 
-TEST_F(RlzLibTest, PingInvalidatesRlzCache) {
+TEST_F(RlzLibTest, PingUpdatesRlzCache) {
   // Set dummy RLZ string.
   rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kOmniboxRlzString);
+  rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, kHomepageRlzString);
 
   std::wstring rlz;
 
   // Prime the cache.
-  tracker_.set_assume_io_thread(true);
+  tracker_.set_assume_not_ui_thread(true);
+
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
   EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz));
+  EXPECT_STREQ(kHomepageRlzString, WideToUTF8(rlz).c_str());
 
   // Make sure cache is valid.
-  tracker_.set_assume_io_thread(false);
+  tracker_.set_assume_not_ui_thread(false);
+
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
   EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz));
+  EXPECT_STREQ(kHomepageRlzString, WideToUTF8(rlz).c_str());
 
   // Perform ping.
+  tracker_.set_assume_not_ui_thread(true);
   RLZTracker::InitRlzDelayed(true, 20, true, true);
   InvokeDelayedInit();
   ExpectRlzPingSent(true);
 
-  // Make sure cache is now invalid.
-  EXPECT_FALSE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
+  // Make sure cache is now updated.
+  tracker_.set_assume_not_ui_thread(false);
+
+  EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
+  EXPECT_STREQ(kNewOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz));
+  EXPECT_STREQ(kNewHomepageRlzString, WideToUTF8(rlz).c_str());
 }
 
 TEST_F(RlzLibTest, ObserveHandlesBadArgs) {
   NavigationEntry entry(NULL, 0, GURL(), GURL(), string16(),
                         PageTransition::LINK);
   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
                    NotificationService::AllSources(),
                    Details<NavigationEntry>(NULL));
   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
                    NotificationService::AllSources(),
                    Details<NavigationEntry>(&entry));
 }