Add support for reactivating a chrome install that originally used an

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"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
+#include "chrome/browser/google/google_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 52 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_not_ui_thread_(false) {
+  TestRLZTracker() : assume_not_ui_thread_(false) {
     set_tracker(this);
   }
 
   virtual ~TestRLZTracker() {
     set_tracker(NULL);
   }
 
-  bool pingnow_called() const {
-    return pingnow_called_;
+  bool was_ping_sent_for_brand(const std::string& brand) const {
+    return pinged_brands_.count(brand) > 0;
   }
 
   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_not_ui_thread_;
   }
 
   virtual bool SendFinancialPing(const std::string& brand,
                                  const string16& lang,
                                  const string16& referral) OVERRIDE {
-    // Don't ping the server during tests.
-    pingnow_called_ = true;
+    // Don't ping the server during tests, just pretend as if we did.
+    EXPECT_FALSE(brand.empty());
+    pinged_brands_.insert(brand);
 
     // 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_;
+  std::set<std::string> pinged_brands_;
   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 SetMainBrand(const char* brand);
+  void SetReactivationBrand(const char* brand);
+  void SetRegistryBrandValue(const wchar_t* name, const char* brand);
+
   void SimulateOmniboxUsage();
   void SimulateHomepageUsage();
   void InvokeDelayedInit();
 
   void ExpectEventRecorded(const char* event_name, bool expected);
   void ExpectRlzPingSent(bool expected);
+  void ExpectReactivationRlzPingSent(bool expected);
 
   TestRLZTracker tracker_;
   RegistryOverrideManager override_manager_;
 };
 
 void RlzLibTest::SetUp() {
   testing::Test::SetUp();
 
   // Before overriding HKLM for the tests, we need to set it up correctly
   // so that the rlz_lib calls work. This needs to be done before we do the
@@ skipping 21 matching lines @@
 
   rlz_lib::InitializeTempHivesForTesting(hklm, hkcu);
 
   // Its important to override HKLM before HKCU because of the registry
   // initialization performed above.
   override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE, kRlzTempHklm);
   override_manager_.OverrideRegistry(HKEY_CURRENT_USER, kRlzTempHkcu);
 
   // Make sure a non-organic brand code is set in the registry or the RLZTracker
   // is pretty much a no-op.
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  string16 reg_path = dist->GetStateKey();
-  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_SET_VALUE);
-  ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(google_update::kRegRLZBrandField,
-                                          L"TEST"));
+  SetMainBrand("TEST");
+  SetReactivationBrand("");
 }
 
 void RlzLibTest::TearDown() {
   testing::Test::TearDown();
 }
 
+void RlzLibTest::SetMainBrand(const char* brand) {
+  SetRegistryBrandValue(google_update::kRegRLZBrandField, brand);
+  std::string check_brand;
+  google_util::GetBrand(&check_brand);
+  EXPECT_EQ(brand, check_brand);
+}
+
+void RlzLibTest::SetReactivationBrand(const char* brand) {
+  SetRegistryBrandValue(google_update::kRegRLZReactivationBrandField, brand);
+  std::string check_brand;
+  google_util::GetReactivationBrand(&check_brand);
+  EXPECT_EQ(brand, check_brand);
+}
+
+void RlzLibTest::SetRegistryBrandValue(const wchar_t* name,
+                                       const char* brand) {
+  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+  string16 reg_path = dist->GetStateKey();
+  RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_SET_VALUE);
+  if (*brand == 0) {
+    LONG result = key.DeleteValue(name);
+    ASSERT_TRUE(ERROR_SUCCESS == result || ERROR_FILE_NOT_FOUND == result);
+  } else {
+    string16 brand16 = ASCIIToWide(brand);
+    ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name, brand16.c_str()));
+  }
+}
+
 void RlzLibTest::SimulateOmniboxUsage() {
   tracker_.Observe(chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
                    content::NotificationService::AllSources(),
                    content::Details<AutocompleteLog>(NULL));
 }
 
 void RlzLibTest::SimulateHomepageUsage() {
   NavigationEntry entry(NULL, 0, GURL(), GURL(), string16(),
                         content::PAGE_TRANSITION_HOME_PAGE, false);
   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
                    content::NotificationService::AllSources(),
                    content::Details<NavigationEntry>(&entry));
 }
 
 void RlzLibTest::InvokeDelayedInit() {
   tracker_.DelayedInit();
 }
 
 void RlzLibTest::ExpectEventRecorded(const char* event_name, bool expected) {
   char cgi[rlz_lib::kMaxCgiLength];
   GetProductEventsAsCgi(rlz_lib::CHROME, cgi, arraysize(cgi));
   if (expected) {
     EXPECT_STR_CONTAINS(cgi, event_name);
   } else {
     EXPECT_STR_NOT_CONTAIN(cgi, event_name);
   }
 }
 
 void RlzLibTest::ExpectRlzPingSent(bool expected) {
-  EXPECT_EQ(expected, tracker_.pingnow_called());
+  std::string brand;
+  google_util::GetBrand(&brand);
+  EXPECT_EQ(expected, tracker_.was_ping_sent_for_brand(brand.c_str()));
+}
+
+void RlzLibTest::ExpectReactivationRlzPingSent(bool expected) {
+  std::string brand;
+  google_util::GetReactivationBrand(&brand);
+  EXPECT_EQ(expected, tracker_.was_ping_sent_for_brand(brand.c_str()));
 }
 
 TEST_F(RlzLibTest, RecordProductEvent) {
   RLZTracker::RecordProductEvent(rlz_lib::CHROME, rlz_lib::CHROME_OMNIBOX,
                                  rlz_lib::FIRST_SEARCH);
 
   ExpectEventRecorded("C1F", true);
 }
 
 // The events that affect the different RLZ scenarios are the following:
@@ skipping 301 matching lines @@
 TEST_F(RlzLibTest, ObserveHandlesBadArgs) {
   NavigationEntry entry(NULL, 0, GURL(), GURL(), string16(),
                         content::PAGE_TRANSITION_LINK, false);
   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
                    content::NotificationService::AllSources(),
                    content::Details<NavigationEntry>(NULL));
   tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
                    content::NotificationService::AllSources(),
                    content::Details<NavigationEntry>(&entry));
 }
+
+TEST_F(RlzLibTest, ReactivationNonOrganicNonOrganic) {
+  SetReactivationBrand("REAC");
+
+  RLZTracker::InitRlzDelayed(true, 20, true, true);
+  InvokeDelayedInit();
+
+  ExpectRlzPingSent(true);
+  ExpectReactivationRlzPingSent(true);
+}
+
+TEST_F(RlzLibTest, ReactivationOrganicNonOrganic) {
+  SetMainBrand("GGLS");
+  SetReactivationBrand("REAC");
+
+  RLZTracker::InitRlzDelayed(true, 20, true, true);
+  InvokeDelayedInit();
+
+  ExpectRlzPingSent(false);
+  ExpectReactivationRlzPingSent(true);
+}
+
+TEST_F(RlzLibTest, ReactivationNonOrganicOrganic) {
+  SetMainBrand("TEST");
+  SetReactivationBrand("GGLS");
+
+  RLZTracker::InitRlzDelayed(true, 20, true, true);
+  InvokeDelayedInit();
+
+  ExpectRlzPingSent(true);
+  ExpectReactivationRlzPingSent(false);
+}
+
+TEST_F(RlzLibTest, ReactivationOrganicOrganic) {
+  SetMainBrand("GGLS");
+  SetReactivationBrand("GGRS");
+
+  RLZTracker::InitRlzDelayed(true, 20, true, true);
+  InvokeDelayedInit();
+
+  ExpectRlzPingSent(false);
+  ExpectReactivationRlzPingSent(false);
+}
+