Only send C2F ping for a search through homepage.

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/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/autocomplete_controller.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/omnibox/omnibox_log.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
+#include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/common/referrer.h"
+#include "content/test/test_render_frame_host.h"
 #include "rlz/test/rlz_test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/registry.h"
 #endif
 
 using content::NavigationEntry;
+using content::LoadCommittedDetails;
 using testing::AssertionResult;
 using testing::AssertionSuccess;
 using testing::AssertionFailure;
 
 #if defined(OS_WIN)
 using base::win::RegKey;
 #endif
 
 namespace {
 
@@ skipping 114 matching lines @@
                                kNewAppListRlzString);
     return true;
   }
 
   std::set<std::string> pinged_brands_;
   bool assume_not_ui_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRLZTracker);
 };
 
-class RlzLibTest : public RlzLibTestNoMachineState {
+class RlzLibTest : public ChromeRenderViewHostTestHarness {
  protected:
   virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
 
   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 SimulateAppListUsage();
   void InvokeDelayedInit();
 
   void ExpectEventRecorded(const char* event_name, bool expected);
   void ExpectRlzPingSent(bool expected);
   void ExpectReactivationRlzPingSent(bool expected);
 
   TestRLZTracker tracker_;
 #if defined(OS_POSIX)
   scoped_ptr<google_brand::BrandForTesting> brand_override_;
+  base::ScopedTempDir temp_dir_;
 #endif
+#if defined(OS_WIN)
+  registry_util::RegistryOverrideManager override_manager_;
+#endif
+
 };
 
 void RlzLibTest::SetUp() {
-  RlzLibTestNoMachineState::SetUp();
+  ChromeRenderViewHostTestHarness::SetUp();
+
+  // Same with RlzLibTestNoMachineState::SetUp().
+#if defined(OS_WIN)
+  InitializeRegistryOverridesForTesting(&override_manager_);
+#elif defined(OS_MACOSX)
+  base::mac::ScopedNSAutoreleasePool pool;
+#endif  // defined(OS_WIN)
+#if defined(OS_POSIX)
+  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  rlz_lib::testing::SetRlzStoreDirectory(temp_dir_.path());
+#endif  // defined(OS_POSIX)
 
   // 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() {
+  ChromeRenderViewHostTestHarness::TearDown();
+
+// Same with RlzLibTestNoMachineState::TearDown().
+#if defined(OS_POSIX)
+  rlz_lib::testing::SetRlzStoreDirectory(base::FilePath());
+#endif  // defined(OS_POSIX)
+}
+
 void RlzLibTest::SetMainBrand(const char* brand) {
 #if defined(OS_WIN)
   SetRegistryBrandValue(google_update::kRegRLZBrandField, brand);
 #elif defined(OS_POSIX)
   brand_override_.reset(new google_brand::BrandForTesting(brand));
 #endif
   std::string check_brand;
   google_brand::GetBrand(&check_brand);
   EXPECT_EQ(brand, check_brand);
 }
@@ skipping 35 matching lines @@
                    base::TimeDelta::FromSeconds(0), 0,
                    base::TimeDelta::FromSeconds(0),
                    AutocompleteResult());
 
   tracker_.Observe(chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
                    content::NotificationService::AllSources(),
                    content::Details<OmniboxLog>(&dummy));
 }
 
 void RlzLibTest::SimulateHomepageUsage() {
-  scoped_ptr<NavigationEntry> entry(NavigationEntry::Create());
-  entry->SetPageID(0);
-  entry->SetTransitionType(ui::PAGE_TRANSITION_HOME_PAGE);
-  tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
-                   content::NotificationService::AllSources(),
-                   content::Details<NavigationEntry>(entry.get()));
+  GURL home_url = GURL("https://www.google.com/");
+  GURL search_url = GURL("https://www.google.com/#q=search");
+
+  content::TestRenderFrameHost* trfh =
+      static_cast<content::TestRenderFrameHost*>(main_rfh());
+
+  // Simulate a navigation to homepage first.
+  trfh->SendNavigateWithTransition(0, home_url, ui::PAGE_TRANSITION_HOME_PAGE);
+  // Then simulate a search from homepage.

[Roger Tawa OOO till Jul 10th, 2014/09/30 14:43:35]

Between the two SendNavigateWithTransition(), would it be good to have a call
to:

   ExpectEventRecorded(kHomepageFirstSeach, false);

[yao, 2014/09/30 17:10:44]

hm.. but kHomepageFirstSeach is defined after this function. 

I could separate this function into 2 functions, one SimulateHomePage and one
SimulateSearch, and have the check done in the test. WDYT?

+  trfh->SendNavigateWithTransition(1, search_url, ui::PAGE_TRANSITION_LINK);
 }
 
 void RlzLibTest::SimulateAppListUsage() {
   RLZTracker::RecordAppListSearch();
 }
 
 void RlzLibTest::InvokeDelayedInit() {
   tracker_.DelayedInit();
 }
 
@@ skipping 549 matching lines @@
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz));
   EXPECT_STREQ(kNewOmniboxRlzString, base::UTF16ToUTF8(rlz).c_str());
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(
         RLZTracker::ChromeHomePage(), &rlz));
   EXPECT_STREQ(kNewHomepageRlzString, base::UTF16ToUTF8(rlz).c_str());
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(RLZTracker::ChromeAppList(), &rlz));
   EXPECT_STREQ(kNewAppListRlzString, base::UTF16ToUTF8(rlz).c_str());
 }
 
 TEST_F(RlzLibTest, ObserveHandlesBadArgs) {
-  scoped_ptr<NavigationEntry> entry(NavigationEntry::Create());
-  entry->SetPageID(0);
-  entry->SetTransitionType(ui::PAGE_TRANSITION_LINK);
-  tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
+  scoped_ptr<LoadCommittedDetails> details(new LoadCommittedDetails());
+  details->entry = NavigationEntry::Create();
+  details->entry->SetPageID(0);
+  details->entry->SetTransitionType(ui::PAGE_TRANSITION_LINK);
+
+  tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    content::NotificationService::AllSources(),
                    content::Details<NavigationEntry>(NULL));
-  tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_PENDING,
+  tracker_.Observe(content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    content::NotificationService::AllSources(),
-                   content::Details<NavigationEntry>(entry.get()));
+                   content::Details<LoadCommittedDetails>(details.get()));
 }
 
 // TODO(thakis): Reactivation doesn't exist on Mac yet.
 #if defined(OS_WIN)
 TEST_F(RlzLibTest, ReactivationNonOrganicNonOrganic) {
   SetReactivationBrand("REAC");
 
   TestRLZTracker::InitRlzDelayed(true, false, kDelay, true, true, false);
   InvokeDelayedInit();
 
@@ skipping 40 matching lines @@
   RLZTracker::RecordProductEvent(rlz_lib::CHROME, RLZTracker::ChromeOmnibox(),
                                  rlz_lib::FIRST_SEARCH);
 
   ExpectEventRecorded(kOmniboxFirstSearch, true);
 
   RLZTracker::ClearRlzState();
 
   ExpectEventRecorded(kOmniboxFirstSearch, false);
 }
 #endif  // defined(OS_CHROMEOS)