rlz: Hook up on mac, switch to chrome's network stack on win.

chrome/browser/rlz/rlz_unittest.cc

 // Copyright (c) 2012 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/scoped_temp_dir.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/public/browser/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 "rlz/win/lib/rlz_lib.h"  // InitializeTempHivesForTesting
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::win::RegKey;
+#if defined(OS_WIN)
+#include "base/test/test_reg_util_win.h"
+#include "base/win/registry.h"
+#include "rlz/win/lib/rlz_lib.h"  // InitializeTempHivesForTesting
+#elif defined(OS_MACOSX)
+#include "rlz/lib/rlz_value_store.h"  // SetRlzStoreDirectory
+#endif
+
 using content::NavigationEntry;
-using registry_util::RegistryOverrideManager;
 using testing::AssertionResult;
 using testing::AssertionSuccess;
 using testing::AssertionFailure;
 
+#if defined(OS_WIN)
+using base::win::RegKey;
+using registry_util::RegistryOverrideManager;
+#endif
+
 namespace {
 
+#if defined(OS_WIN)
 // Registry path to overridden hive.
 const wchar_t kRlzTempHkcu[] = L"rlz_hkcu";
 const wchar_t kRlzTempHklm[] = L"rlz_hklm";
+#endif
 
 // 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,
@@ skipping 90 matching lines @@
   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);
+#if defined(OS_WIN)
   void SetRegistryBrandValue(const wchar_t* name, const char* brand);
+#endif
 
   void SimulateOmniboxUsage();
   void SimulateHomepageUsage();
   void InvokeDelayedInit();
 
   void ExpectEventRecorded(const char* event_name, bool expected);
   void ExpectRlzPingSent(bool expected);
   void ExpectReactivationRlzPingSent(bool expected);
 
   TestRLZTracker tracker_;
+#if defined(OS_WIN)
   RegistryOverrideManager override_manager_;
+#elif defined(OS_MACOSX)
+  ScopedTempDir temp_dir_;
+  scoped_ptr<google_util::BrandForTesting> brand_override_;

[Roger Tawa OOO till Jul 10th, 2012/03/26 18:52:38]

just a question: is it possible to use BrandForTesting for windows as well?

[Nico, 2012/03/26 20:26:57]

I think so. (It would make the test more of a unit test and less of an
integration test on windows, which is why I didn't' do it.)

+#endif
 };
 
 void RlzLibTest::SetUp() {
   testing::Test::SetUp();
 
+#if defined(OS_WIN)
   // 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
   // override.
 
   string16 temp_hklm_path = base::StringPrintf(
       L"%ls\\%ls",
       RegistryOverrideManager::kTempTestKeyPath,
       kRlzTempHklm);
 
   base::win::RegKey hklm;
@@ skipping 10 matching lines @@
   ASSERT_EQ(ERROR_SUCCESS, hkcu.Create(HKEY_CURRENT_USER,
                                        temp_hkcu_path.c_str(),
                                        KEY_READ));
 
   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);
+#elif defined(OS_MACOSX)
+  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  rlz_lib::testing::SetRlzStoreDirectory(temp_dir_.path());
+#endif
 
   // Make sure a non-organic brand code is set in the registry or the RLZTracker
   // is pretty much a no-op.
   SetMainBrand("TEST");
   SetReactivationBrand("");
 }
 
 void RlzLibTest::TearDown() {
+#if defined(OS_MACOSX)
+  rlz_lib::testing::SetRlzStoreDirectory(FilePath());
+#endif
   testing::Test::TearDown();
 }
 
 void RlzLibTest::SetMainBrand(const char* brand) {
+#if defined(OS_WIN)
   SetRegistryBrandValue(google_update::kRegRLZBrandField, brand);
+#elif defined(OS_MACOSX)
+  brand_override_.reset(new google_util::BrandForTesting(brand));
+#endif
   std::string check_brand;
   google_util::GetBrand(&check_brand);
   EXPECT_EQ(brand, check_brand);
 }
 
 void RlzLibTest::SetReactivationBrand(const char* brand) {
+  // TODO(thakis): Reactivation doesn't exist on Mac yet.
+#if defined(OS_WIN)
   SetRegistryBrandValue(google_update::kRegRLZReactivationBrandField, brand);
   std::string check_brand;
   google_util::GetReactivationBrand(&check_brand);
   EXPECT_EQ(brand, check_brand);
+#endif
 }
 
+#if defined(OS_WIN)
 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);
+    string16 brand16 = ASCIIToUTF16(brand);
     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(name, brand16.c_str()));
   }
 }
+#endif
 
 void RlzLibTest::SimulateOmniboxUsage() {
   tracker_.Observe(chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
                    content::NotificationService::AllSources(),
                    content::Details<AutocompleteLog>(NULL));
 }
 
 void RlzLibTest::SimulateHomepageUsage() {
   scoped_ptr<NavigationEntry> entry(NavigationEntry::Create());
   entry->SetPageID(0);
@@ skipping 262 matching lines @@
 }
 
 TEST_F(RlzLibTest, GetAccessPointRlzOnIoThread) {
   // Set dummy RLZ string.
   rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kOmniboxRlzString);
 
   string16 rlz;
 
   tracker_.set_assume_not_ui_thread(true);
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
-  EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kOmniboxRlzString, UTF16ToUTF8(rlz).c_str());
 }
 
 TEST_F(RlzLibTest, GetAccessPointRlzNotOnIoThread) {
   // Set dummy RLZ string.
   rlz_lib::SetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, kOmniboxRlzString);
 
   string16 rlz;
 
   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);
 
   string16 rlz;
 
   tracker_.set_assume_not_ui_thread(false);
   EXPECT_FALSE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
 
   tracker_.set_assume_not_ui_thread(true);
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
-  EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kOmniboxRlzString, UTF16ToUTF8(rlz).c_str());
 
   tracker_.set_assume_not_ui_thread(false);
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
-  EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kOmniboxRlzString, UTF16ToUTF8(rlz).c_str());
 }
 
 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);
 
   string16 rlz;
 
   // Prime the cache.
   tracker_.set_assume_not_ui_thread(true);
 
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
-  EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kOmniboxRlzString, UTF16ToUTF8(rlz).c_str());
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz));
-  EXPECT_STREQ(kHomepageRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kHomepageRlzString, UTF16ToUTF8(rlz).c_str());
 
   // Make sure cache is valid.
   tracker_.set_assume_not_ui_thread(false);
 
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz));
-  EXPECT_STREQ(kOmniboxRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kOmniboxRlzString, UTF16ToUTF8(rlz).c_str());
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz));
-  EXPECT_STREQ(kHomepageRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kHomepageRlzString, UTF16ToUTF8(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 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_STREQ(kNewOmniboxRlzString, UTF16ToUTF8(rlz).c_str());
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_HOME_PAGE, &rlz));
-  EXPECT_STREQ(kNewHomepageRlzString, WideToUTF8(rlz).c_str());
+  EXPECT_STREQ(kNewHomepageRlzString, UTF16ToUTF8(rlz).c_str());
 }
 
 TEST_F(RlzLibTest, ObserveHandlesBadArgs) {
   scoped_ptr<NavigationEntry> entry(NavigationEntry::Create());
   entry->SetPageID(0);
   entry->SetTransitionType(content::PAGE_TRANSITION_LINK);
   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.get()));
 }
 
+// TODO(thakis): Reactivation doesn't exist on Mac yet.
+#if defined(OS_WIN)
 TEST_F(RlzLibTest, ReactivationNonOrganicNonOrganic) {
   SetReactivationBrand("REAC");
 
   RLZTracker::InitRlzDelayed(true, 20, true, true);
   InvokeDelayedInit();
 
   ExpectRlzPingSent(true);
   ExpectReactivationRlzPingSent(true);
 }
 
@@ skipping 22 matching lines @@
 TEST_F(RlzLibTest, ReactivationOrganicOrganic) {
   SetMainBrand("GGLS");
   SetReactivationBrand("GGRS");
 
   RLZTracker::InitRlzDelayed(true, 20, true, true);
   InvokeDelayedInit();
 
   ExpectRlzPingSent(false);
   ExpectReactivationRlzPingSent(false);
 }
-
+#endif  // defined(OS_WIN)