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/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 59 matching lines @@
 
   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(base::TimeDelta delay) override {
+  virtual void ScheduleDelayedInit(base::TimeDelta 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 == base::TimeDelta())
       DelayedInit();
   }
 
-  virtual void ScheduleFinancialPing() override {
+  virtual void ScheduleFinancialPing() OVERRIDE {
     PingNowImpl();
   }
 
   virtual bool ScheduleRecordProductEvent(rlz_lib::Product product,
                                           rlz_lib::AccessPoint point,
-                                          rlz_lib::Event event_id) override {
+                                          rlz_lib::Event event_id) OVERRIDE {
     return !assume_not_ui_thread_;
   }
 
-  virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) override {
+  virtual bool ScheduleGetAccessPointRlz(rlz_lib::AccessPoint point) OVERRIDE {
     return !assume_not_ui_thread_;
   }
 
-  virtual bool ScheduleRecordFirstSearch(rlz_lib::AccessPoint point) override {
+  virtual bool ScheduleRecordFirstSearch(rlz_lib::AccessPoint point) OVERRIDE {
     return !assume_not_ui_thread_;
   }
 
 #if defined(OS_CHROMEOS)
-  virtual bool ScheduleClearRlzState() override {
+  virtual bool ScheduleClearRlzState() OVERRIDE {
     return !assume_not_ui_thread_;
   }
 #endif
 
   virtual bool SendFinancialPing(const std::string& brand,
                                  const base::string16& lang,
-                                 const base::string16& referral) override {
+                                 const base::string16& referral) OVERRIDE {
     // 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(RLZTracker::ChromeOmnibox(),
                                kNewOmniboxRlzString);
     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeHomePage(),
                                kNewHomepageRlzString);
     rlz_lib::SetAccessPointRlz(RLZTracker::ChromeAppList(),
                                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 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_;
-#endif
+  RlzLibTestNoMachineStateHelper m_rlz_test_helper_;
 };
 
 void RlzLibTest::SetUp() {
-  RlzLibTestNoMachineState::SetUp();
+  ChromeRenderViewHostTestHarness::SetUp();
+  m_rlz_test_helper_.SetUp();
 
   // 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();
+  m_rlz_test_helper_.TearDown();
+}
+
 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.
+  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)