Add new tab feature engagement tracker

To use the FeatureEngagementTracker to observe the New Tab and related
actions, the NewTabFeatureEngagementTracker class was created.

Things that were changed in this CL:
* Added the NewTabInProductHelp trial to the fieldtrial json
* Added a pref to track the user's total active session time
* Created a NewTabFeatureEngagementTracker class, which contains
methods to notify the IPH server when events happen and if the help
UI should be triggered.

Related CLs:
* The Observer for DesktopSessionDurationTracker
  http://crrev.com/d69292f
* Event constants that are used in NewTabFeatureEngagementTracker
  http://crrev.com/bdf5c97
* Using the NewTabFeatureEngagementTracker
  https://chromium-review.googlesource.com/c/549074/
* Addition to fieldtrial_testing.json
  https://chromium-review.googlesource.com/c/566335/

Bug: 734132
Change-Id: I8654ef001f3fb50fbd8bb8c4f215dffcfe403762
Reviewed-on: https://chromium-review.googlesource.com/549057
Commit-Queue: Catherine Chung <catherinechung@google.com>
Reviewed-by: Tommy Nyquist <nyquist@chromium.org>
Reviewed-by: Robert Liao <robliao@chromium.org>
Reviewed-by: Pam Greene <pam@chromium.org>
Reviewed-by: Anthony Vallee-Dubois <anthonyvd@chromium.org>
Reviewed-by: Erik Chen <erikchen@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488293}

chrome/browser/BUILD.gn

@@ -3649,6 +3649,15 @@ split_static_library("browser") {
     ]
   }
 
+  if ((is_linux && !is_chromeos) || is_win) {
+    sources += [
+      "feature_engagement_tracker/new_tab/new_tab_tracker.cc",
+      "feature_engagement_tracker/new_tab/new_tab_tracker.h",
+      "feature_engagement_tracker/new_tab/new_tab_tracker_factory.cc",
+      "feature_engagement_tracker/new_tab/new_tab_tracker_factory.h",
+    ]
+  }
+
   if (is_desktop_linux) {
     # Desktop linux, doesn't count ChromeOS.
     sources += [

chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker.cc

+// Copyright 2017 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/feature_engagement_tracker/new_tab/new_tab_tracker.h"
+
+#include "base/time/time.h"
+#include "chrome/browser/feature_engagement_tracker/feature_engagement_tracker_factory.h"
+#include "chrome/browser/metrics/desktop_session_duration/desktop_session_duration_tracker.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/pref_names.h"
+#include "components/feature_engagement_tracker/public/event_constants.h"
+#include "components/feature_engagement_tracker/public/feature_constants.h"
+#include "components/feature_engagement_tracker/public/feature_engagement_tracker.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "components/prefs/pref_service.h"
+
+namespace {
+
+const int kTwoHoursInMinutes = 120;
+
+}  // namespace
+
+namespace feature_engagement_tracker {
+
+NewTabTracker::NewTabTracker(Profile* profile)
+    : duration_tracker_(metrics::DesktopSessionDurationTracker::Get()),
+      profile_(profile) {
+  duration_tracker_->AddObserver(this);
+}
+
+NewTabTracker::NewTabTracker()
+    : duration_tracker_(metrics::DesktopSessionDurationTracker::Get()),
+      profile_(nullptr) {}
+
+NewTabTracker::~NewTabTracker() = default;
+
+// static
+void NewTabTracker::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterBooleanPref(prefs::kNewTabInProductHelp, false);
+  registry->RegisterIntegerPref(prefs::kSessionTimeTotal, 0);
+}
+
+void NewTabTracker::DismissNewTabTracker() {
+  GetFeatureTracker()->Dismissed(kIPHNewTabFeature);
+}
+
+void NewTabTracker::OnNewTabOpened() {
+  GetFeatureTracker()->NotifyEvent(events::kNewTabOpened);
+}
+
+void NewTabTracker::OnOmniboxNavigation() {
+  GetFeatureTracker()->NotifyEvent(events::kOmniboxInteraction);
+}
+
+void NewTabTracker::OnSessionTimeMet() {
+  GetFeatureTracker()->NotifyEvent(events::kSessionTime);
+}
+
+void NewTabTracker::OnOmniboxFocused() {
+  if (ShouldShowPromo())
+    ShowPromo();
+}
+
+void NewTabTracker::ShowPromo() {
+  GetPrefs()->SetBoolean(prefs::kNewTabInProductHelp, true);
+  // TODO(crbug.com/737830): Call the promo.
+
+  // Clears the flag for whether there is any in-product help being displayed.
+  GetFeatureTracker()->Dismissed(kIPHNewTabFeature);
+}
+
+bool NewTabTracker::ShouldShowPromo() {
+  return GetFeatureTracker()->ShouldTriggerHelpUI(kIPHNewTabFeature);
+}
+
+FeatureEngagementTracker* NewTabTracker::GetFeatureTracker() {
+  return FeatureEngagementTrackerFactory::GetForBrowserContext(profile_);
+}
+
+PrefService* NewTabTracker::GetPrefs() {
+  return profile_->GetPrefs();
+}
+
+bool NewTabTracker::HasEnoughSessionTimeElapsed() {
+  return GetPrefs()->GetInteger(prefs::kSessionTimeTotal) >= kTwoHoursInMinutes;
+}
+
+void NewTabTracker::UpdateSessionTime(base::TimeDelta elapsed) {
+  // Session time does not need to be tracked anymore if the
+  // in-product help has been shown already.
+  // This prevents unnecessary interaction with prefs.
+  if (GetPrefs()->GetBoolean(prefs::kNewTabInProductHelp))
+    return;
+
+  base::TimeDelta elapsed_session_time;
+  elapsed_session_time += base::TimeDelta::FromMinutes(GetPrefs()->GetInteger(
+                              prefs::kSessionTimeTotal)) +
+                          elapsed;
+  GetPrefs()->SetInteger(prefs::kSessionTimeTotal,
+                         elapsed_session_time.InMinutes());
+}
+
+void NewTabTracker::OnSessionEnded(base::TimeDelta delta) {
+  UpdateSessionTime(delta);
+  if (HasEnoughSessionTimeElapsed()) {
+    OnSessionTimeMet();
+    duration_tracker_->RemoveObserver(this);
+  }
+}
+
+}  // namespace feature_engagement_tracker

chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker.h

+// Copyright 2017 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.
+
+#ifndef CHROME_BROWSER_FEATURE_ENGAGEMENT_TRACKER_NEW_TAB_NEW_TAB_TRACKER_H_
+#define CHROME_BROWSER_FEATURE_ENGAGEMENT_TRACKER_NEW_TAB_NEW_TAB_TRACKER_H_
+
+#include "chrome/browser/metrics/desktop_session_duration/desktop_session_duration_tracker.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/feature_engagement_tracker/public/feature_engagement_tracker.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+namespace user_prefs {
+class PrefRegistrySyncable;
+}  // namespace user_prefs
+
+namespace feature_engagement_tracker {
+
+// The NewTabTracker provides a backend for displaying
+// in-product help for the new tab button.
+class NewTabTracker : public metrics::DesktopSessionDurationTracker::Observer,
+                      public KeyedService {
+ public:
+  explicit NewTabTracker(Profile* profile);
+
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
+  // Clears the flag for whether there is any in-product help being displayed.
+  void DismissNewTabTracker();
+  // Alerts the new tab tracker that a new tab was opened.
+  void OnNewTabOpened();
+  // Alerts the new tab tracker that the omnibox has been used.
+  void OnOmniboxNavigation();
+  // Alerts the new tab tracker that the session time is up.
+  void OnSessionTimeMet();
+  // Checks if the promo should be displayed since the omnibox is on focus.
+  void OnOmniboxFocused();
+  // Returns whether or not the promo should be displayed.
+  bool ShouldShowPromo();
+
+ protected:
+  NewTabTracker();
+  ~NewTabTracker() override;
+
+ private:
+  // Returns whether the active session time of a user has elapsed
+  // more than two hours.
+  bool HasEnoughSessionTimeElapsed();
+
+  // Returns whether the NewTabInProductHelp field trial is enabled.
+  bool IsIPHNewTabEnabled();
+
+  // Sets the NewTabInProductHelp pref to true and calls the New Tab Promo.
+  void ShowPromo();
+
+  // Virtual to support mocking by unit tests.
+  virtual FeatureEngagementTracker* GetFeatureTracker();
+
+  virtual PrefService* GetPrefs();
+
+  // Updates the pref that stores active session time per user unless the
+  // new tab in-product help has been displayed already.
+  virtual void UpdateSessionTime(base::TimeDelta elapsed);
+
+  // metrics::DesktopSessionDurationtracker::Observer::
+  void OnSessionEnded(base::TimeDelta delta) override;
+
+  // These pointers are owned by NewTabTracker.
+  metrics::DesktopSessionDurationTracker* const duration_tracker_;
+
+  Profile* const profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(NewTabTracker);
+};
+
+}  // namespace feature_engagement_tracker
+
+#endif  // CHROME_BROWSER_FEATURE_ENGAGEMENT_TRACKER_NEW_TAB_NEW_TAB_TRACKER_H_

chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker_factory.cc

+// Copyright 2017 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/feature_engagement_tracker/new_tab/new_tab_tracker_factory.h"
+
+#include "base/memory/singleton.h"
+#include "chrome/browser/feature_engagement_tracker/feature_engagement_tracker_factory.h"
+#include "chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker.h"
+#include "chrome/browser/profiles/incognito_helpers.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "content/public/browser/browser_context.h"
+
+namespace feature_engagement_tracker {
+
+// static
+NewTabTrackerFactory* NewTabTrackerFactory::GetInstance() {
+  return base::Singleton<NewTabTrackerFactory>::get();
+}
+
+NewTabTracker* NewTabTrackerFactory::GetForProfile(Profile* profile) {
+  return static_cast<NewTabTracker*>(
+      GetInstance()->GetServiceForBrowserContext(profile, true));
+}
+
+NewTabTrackerFactory::NewTabTrackerFactory()
+    : BrowserContextKeyedServiceFactory(
+          "NewTabTracker",
+          BrowserContextDependencyManager::GetInstance()) {
+  DependsOn(FeatureEngagementTrackerFactory::GetInstance());
+}
+
+NewTabTrackerFactory::~NewTabTrackerFactory() = default;
+
+KeyedService* NewTabTrackerFactory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  return new NewTabTracker(Profile::FromBrowserContext(context));
+}
+
+content::BrowserContext* NewTabTrackerFactory::GetBrowserContextToUse(
+    content::BrowserContext* context) const {
+  return chrome::GetBrowserContextRedirectedInIncognito(context);
+}
+
+}  // namespace feature_engagement_tracker

chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker_factory.h

+// Copyright 2017 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.
+
+#ifndef CHROME_BROWSER_FEATURE_ENGAGEMENT_TRACKER_NEW_TAB_NEW_TAB_TRACKER_FACTORY_H_
+#define CHROME_BROWSER_FEATURE_ENGAGEMENT_TRACKER_NEW_TAB_NEW_TAB_TRACKER_FACTORY_H_
+
+#include "base/macros.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+class Profile;
+
+namespace base {
+template <typename T>
+struct DefaultSingletonTraits;
+}  // namespace base
+
+namespace content {
+class BrowserContext;
+}  // namespace content
+
+namespace feature_engagement_tracker {
+class NewTabTracker;
+
+// NewTabTrackerFactory is the main client class for
+// interaction with the NewTabTracker component.
+class NewTabTrackerFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  // Returns singleton instance of NewTabTrackerFactory.
+  static NewTabTrackerFactory* GetInstance();
+
+  // Returns the FeatureEngagementTracker associated with the profile.
+  NewTabTracker* GetForProfile(Profile* profile);
+
+ private:
+  friend struct base::DefaultSingletonTraits<NewTabTrackerFactory>;
+
+  NewTabTrackerFactory();
+  ~NewTabTrackerFactory() override;
+
+  // BrowserContextKeyedServiceFactory overrides:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(NewTabTrackerFactory);
+};
+
+}  // namespace feature_engagement_tracker
+
+#endif  // CHROME_BROWSER_FEATURE_ENGAGEMENT_TRACKER_NEW_TAB_NEW_TAB_TRACKER_FACTORY_H_

chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker_unittest.cc

+// Copyright 2017 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/feature_engagement_tracker/new_tab/new_tab_tracker.h"
+
+#include "base/feature_list.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/field_trial_param_associator.h"
+#include "base/metrics/field_trial_params.h"
+#include "base/run_loop.h"
+#include "base/sequenced_task_runner.h"
+#include "base/test/scoped_feature_list.h"
+#include "chrome/browser/metrics/desktop_session_duration/desktop_session_duration_tracker.h"
+#include "chrome/common/pref_names.h"
+#include "components/feature_engagement_tracker/public/event_constants.h"
+#include "components/feature_engagement_tracker/public/feature_constants.h"
+#include "components/feature_engagement_tracker/public/feature_engagement_tracker.h"
+#include "components/feature_engagement_tracker/test/test_feature_engagement_tracker.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "components/variations/variations_params_manager.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace feature_engagement_tracker {
+
+namespace {
+
+const char kGroupName[] = "Enabled";
+const char kNewTabTrialName[] = "NewTabTrial";
+
+class MockFeatureEngagementTracker : public FeatureEngagementTracker {
+ public:
+  MockFeatureEngagementTracker() = default;
+  MOCK_METHOD1(NotifyEvent, void(const std::string& event));
+  MOCK_METHOD1(ShouldTriggerHelpUI, bool(const base::Feature& feature));
+  MOCK_METHOD1(Dismissed, void(const base::Feature& feature));
+  MOCK_METHOD0(IsInitialized, bool());
+  MOCK_METHOD1(AddOnInitializedCallback, void(OnInitializedCallback callback));
+};
+
+class FakeNewTabTracker : public NewTabTracker {
+ public:
+  explicit FakeNewTabTracker(FeatureEngagementTracker* feature_tracker)
+      : feature_tracker_(feature_tracker),
+        pref_service_(
+            base::MakeUnique<sync_preferences::TestingPrefServiceSyncable>()) {
+    NewTabTracker::RegisterProfilePrefs(pref_service_->registry());
+  }
+
+  // feature_engagement_tracker::NewTabTracker::
+  FeatureEngagementTracker* GetFeatureTracker() override {
+    return feature_tracker_;
+  }
+
+  PrefService* GetPrefs() override { return pref_service_.get(); }
+
+ private:
+  FeatureEngagementTracker* const feature_tracker_;
+  const std::unique_ptr<sync_preferences::TestingPrefServiceSyncable>
+      pref_service_;
+};
+
+class NewTabTrackerEventTest : public testing::Test {
+ public:
+  NewTabTrackerEventTest() = default;
+  ~NewTabTrackerEventTest() override = default;
+
+  // testing::Test:
+  void SetUp() override {
+    // Start the DesktopSessionDurationTracker to track active session time.
+    metrics::DesktopSessionDurationTracker::Initialize();
+    mock_feature_tracker_ =
+        base::MakeUnique<testing::StrictMock<MockFeatureEngagementTracker>>();
+    new_tab_tracker_ =
+        base::MakeUnique<FakeNewTabTracker>(mock_feature_tracker_.get());
+  }
+
+  void TearDown() override {
+    metrics::DesktopSessionDurationTracker::Get()->RemoveObserver(
+        new_tab_tracker_.get());
+    metrics::DesktopSessionDurationTracker::CleanupForTesting();
+  }
+
+ protected:
+  std::unique_ptr<FakeNewTabTracker> new_tab_tracker_;
+  std::unique_ptr<MockFeatureEngagementTracker> mock_feature_tracker_;
+
+ private:
+  content::TestBrowserThreadBundle thread_bundle_;
+
+  DISALLOW_COPY_AND_ASSIGN(NewTabTrackerEventTest);
+};
+
+}  // namespace
+
+// Tests to verify FeatureEngagementTracker API boundary expectations:
+
+// If OnNewTabOpened() is called, the FeatureEngagementTracker
+// receives the kNewTabOpenedEvent.
+TEST_F(NewTabTrackerEventTest, TestOnNewTabOpened) {
+  EXPECT_CALL(*mock_feature_tracker_, NotifyEvent(events::kNewTabOpened));
+  new_tab_tracker_->OnNewTabOpened();
+}
+
+// If OnOmniboxNavigation() is called, the FeatureEngagementTracker
+// receives the kOmniboxInteraction event.
+TEST_F(NewTabTrackerEventTest, TestOnOmniboxNavigation) {
+  EXPECT_CALL(*mock_feature_tracker_, NotifyEvent(events::kOmniboxInteraction));
+  new_tab_tracker_->OnOmniboxNavigation();
+}
+
+// If OnSessionTimeMet() is called, the FeatureEngagementTracker
+// receives the kSessionTime event.
+TEST_F(NewTabTrackerEventTest, TestOnSessionTimeMet) {
+  EXPECT_CALL(*mock_feature_tracker_, NotifyEvent(events::kSessionTime));
+  new_tab_tracker_->OnSessionTimeMet();
+}
+
+namespace {
+
+class NewTabTrackerFeatureEngagementTrackerTest : public testing::Test {
+ public:
+  NewTabTrackerFeatureEngagementTrackerTest() = default;
+  ~NewTabTrackerFeatureEngagementTrackerTest() override = default;
+
+  // testing::Test:
+  void SetUp() override {
+    // Set up the NewTabInProductHelp field trial.
+    base::FieldTrial* new_tab_trial =
+        base::FieldTrialList::CreateFieldTrial(kNewTabTrialName, kGroupName);
+    trials_[kIPHNewTabFeature.name] = new_tab_trial;
+
+    std::unique_ptr<base::FeatureList> feature_list =
+        base::MakeUnique<base::FeatureList>();
+    feature_list->RegisterFieldTrialOverride(
+        kIPHNewTabFeature.name, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
+        new_tab_trial);
+
+    scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
+    ASSERT_EQ(new_tab_trial,
+              base::FeatureList::GetFieldTrial(kIPHNewTabFeature));
+
+    std::map<std::string, std::string> new_tab_params;
+    new_tab_params["event_new_tab_opened"] =
+        "name:new_tab_opened;comparator:==0;window:3650;storage:3650";
+    new_tab_params["event_omnibox_used"] =
+        "name:omnibox_used;comparator:>=1;window:3650;storage:3650";
+    new_tab_params["event_session_time"] =
+        "name:session_time;comparator:>=1;window:3650;storage:3650";
+    new_tab_params["event_trigger"] =
+        "name:new_tab_trigger;comparator:any;window:3650;storage:3650";
+    new_tab_params["event_used"] =
+        "name:new_tab_clicked;comparator:any;window:3650;storage:3650";
+    new_tab_params["session_rate"] = "<=3";
+    new_tab_params["availability"] = "any";
+
+    SetFeatureParams(kIPHNewTabFeature, new_tab_params);
+
+    // Start the DesktopSessionDurationTracker to track active session time.
+    metrics::DesktopSessionDurationTracker::Initialize();
+
+    feature_engagement_tracker_ = CreateTestFeatureEngagementTracker();
+
+    new_tab_tracker_ =
+        base::MakeUnique<FakeNewTabTracker>(feature_engagement_tracker_.get());
+
+    // The feature engagement tracker does async initialization.
+    base::RunLoop().RunUntilIdle();
+    ASSERT_TRUE(feature_engagement_tracker_->IsInitialized());
+  }
+
+  void TearDown() override {
+    metrics::DesktopSessionDurationTracker::Get()->RemoveObserver(
+        new_tab_tracker_.get());
+    metrics::DesktopSessionDurationTracker::CleanupForTesting();
+
+    // This is required to ensure each test can define its own params.
+    base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
+  }
+
+  void SetFeatureParams(const base::Feature& feature,
+                        std::map<std::string, std::string> params) {
+    ASSERT_TRUE(
+        base::FieldTrialParamAssociator::GetInstance()
+            ->AssociateFieldTrialParams(trials_[feature.name]->trial_name(),
+                                        kGroupName, params));
+
+    std::map<std::string, std::string> actualParams;
+    EXPECT_TRUE(base::GetFieldTrialParamsByFeature(feature, &actualParams));
+    EXPECT_EQ(params, actualParams);
+  }
+
+ protected:
+  std::unique_ptr<FakeNewTabTracker> new_tab_tracker_;
+  std::unique_ptr<FeatureEngagementTracker> feature_engagement_tracker_;
+  variations::testing::VariationParamsManager params_manager_;
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+  content::TestBrowserThreadBundle thread_bundle_;
+  std::map<std::string, base::FieldTrial*> trials_;
+
+  DISALLOW_COPY_AND_ASSIGN(NewTabTrackerFeatureEngagementTrackerTest);
+};
+
+}  // namespace
+
+// Tests to verify NewTabFeatureEngagementTracker functional expectations:
+
+// Test that a promo is not shown if the user uses a New Tab.
+// If OnNewTabOpened() is called, the ShouldShowPromo() should return false.
+TEST_F(NewTabTrackerFeatureEngagementTrackerTest, TestShouldNotShowPromo) {
+  EXPECT_FALSE(new_tab_tracker_->ShouldShowPromo());
+
+  new_tab_tracker_->OnSessionTimeMet();
+  new_tab_tracker_->OnOmniboxNavigation();
+
+  EXPECT_TRUE(new_tab_tracker_->ShouldShowPromo());
+
+  new_tab_tracker_->OnNewTabOpened();
+
+  EXPECT_FALSE(new_tab_tracker_->ShouldShowPromo());
+}
+
+// Test that a promo is shown if the session time is met and an omnibox
+// navigation occurs. If OnSessionTimeMet() and OnOmniboxNavigation()
+// are called, ShouldShowPromo() should return true.
+TEST_F(NewTabTrackerFeatureEngagementTrackerTest, TestShouldShowPromo) {
+  EXPECT_FALSE(new_tab_tracker_->ShouldShowPromo());
+
+  new_tab_tracker_->OnSessionTimeMet();
+  new_tab_tracker_->OnOmniboxNavigation();
+
+  EXPECT_TRUE(new_tab_tracker_->ShouldShowPromo());
+}
+
+// Test that the prefs for session time is being correctly set.
+TEST_F(NewTabTrackerFeatureEngagementTrackerTest, TestPrefs) {
+  EXPECT_FALSE(
+      new_tab_tracker_->GetPrefs()->GetBoolean(prefs::kNewTabInProductHelp));
+
+  new_tab_tracker_->OnSessionTimeMet();
+  new_tab_tracker_->OnOmniboxNavigation();
+  new_tab_tracker_->OnOmniboxFocused();
+
+  EXPECT_TRUE(
+      new_tab_tracker_->GetPrefs()->GetBoolean(prefs::kNewTabInProductHelp));
+}
+
+// Test that the correct duration of session is being recorded.
+TEST_F(NewTabTrackerFeatureEngagementTrackerTest, TestOnSessionEnded) {
+  metrics::DesktopSessionDurationTracker::Observer* observer =
+      dynamic_cast<FakeNewTabTracker*>(new_tab_tracker_.get());
+
+  // Simulate passing 30 active minutes.
+  observer->OnSessionEnded(base::TimeDelta::FromMinutes(30));
+
+  EXPECT_EQ(30,
+            new_tab_tracker_->GetPrefs()->GetInteger(prefs::kSessionTimeTotal));
+
+  // Simulate passing 50 minutes.
+  observer->OnSessionEnded(base::TimeDelta::FromMinutes(50));
+
+  EXPECT_EQ(80,
+            new_tab_tracker_->GetPrefs()->GetInteger(prefs::kSessionTimeTotal));
+}
+
+}  // namespace feature_engagement_tracker

chrome/browser/prefs/browser_prefs.cc

@@ -262,6 +262,10 @@
 #include "chrome/browser/ui/desktop_ios_promotion/desktop_ios_promotion_util.h"
 #endif
 
+#if !defined(OS_ANDROID) && !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
+#include "chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker.h"
+#endif
+
 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 #include "chrome/browser/ui/startup/default_browser_prompt.h"
 #endif
@@ -582,6 +586,10 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   default_apps::RegisterProfilePrefs(registry);
 #endif
 
+#if !defined(OS_ANDROID) && !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
+  feature_engagement_tracker::NewTabTracker::RegisterProfilePrefs(registry);
+#endif
+
 #if defined(OS_CHROMEOS)
   arc::ArcSessionManager::RegisterProfilePrefs(registry);
   arc::ArcPolicyBridge::RegisterProfilePrefs(registry);

chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.cc

@@ -26,6 +26,7 @@
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/engagement/site_engagement_service_factory.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
+#include "chrome/browser/feature_engagement_tracker/feature_engagement_tracker_factory.h"
 #include "chrome/browser/google/google_url_tracker_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
@@ -141,6 +142,10 @@
 #include "chrome/browser/ui/desktop_ios_promotion/sms_service_factory.h"
 #endif
 
+#if !defined(OS_ANDROID) && !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
+#include "chrome/browser/feature_engagement_tracker/new_tab/new_tab_tracker_factory.h"
+#endif
+
 #if BUILDFLAG(ENABLE_SPELLCHECK)
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #endif
@@ -238,6 +243,7 @@ EnsureBrowserContextKeyedServiceFactoriesBuilt() {
   extensions::VerifyTrustAPI::GetFactoryInstance();
 #endif
   FaviconServiceFactory::GetInstance();
+  FeatureEngagementTrackerFactory::GetInstance();
   FindBarStateFactory::GetInstance();
   GAIAInfoUpdateServiceFactory::GetInstance();
 #if !defined(OS_ANDROID)
@@ -283,6 +289,9 @@ EnsureBrowserContextKeyedServiceFactoriesBuilt() {
 #if !defined(OS_ANDROID)
   MediaGalleriesPreferencesFactory::GetInstance();
   NTPResourceCacheFactory::GetInstance();
+#endif
+#if !defined(OS_ANDROID) && !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
+  feature_engagement_tracker::NewTabTrackerFactory::GetInstance();
 #endif
   ContentSuggestionsServiceFactory::GetInstance();
   PasswordStoreFactory::GetInstance();

chrome/common/pref_names.cc

@@ -124,6 +124,9 @@ const char kLastProfileResetTimestamp[] = "profile.last_reset_timestamp";
 const char kChromeCleanerResetPending[] = "chrome_cleaner.reset_pending";
 #endif
 
+// Used to determine if the New Tab in-product help has been shown or not.
+extern const char kNewTabInProductHelp[] = "newtab_in_product_help";
+
 // The URL to open the new tab page to. Only set by Group Policy.
 const char kNewTabPageLocationOverride[] = "newtab_page_location_override";
 
@@ -144,6 +147,9 @@ const char kSessionExitedCleanly[] = "profile.exited_cleanly";
 // shutdown. Used to determine the exit type the last time the profile was open.
 const char kSessionExitType[] = "profile.exit_type";
 
+// Stores the total amount of active session time for the user.
+const char kSessionTimeTotal[] = "profile.total_time";
+
 // The last time that the site engagement service recorded an engagement event
 // for this profile for any URL. Recorded only during shutdown. Used to prevent
 // the service from decaying engagement when a user does not use Chrome at all

chrome/common/pref_names.h

@@ -51,11 +51,13 @@ extern const char kImportantSitesDialogHistory[];
 extern const char kLastProfileResetTimestamp[];
 extern const char kChromeCleanerResetPending[];
 #endif
+extern const char kNewTabInProductHelp[];
 extern const char kNewTabPageLocationOverride[];
 extern const char kProfileIconVersion[];
 extern const char kRestoreOnStartup[];
 extern const char kSessionExitedCleanly[];
 extern const char kSessionExitType[];
+extern const char kSessionTimeTotal[];
 extern const char kSiteEngagementLastUpdateTime[];
 extern const char kSupervisedUserApprovedExtensions[];
 extern const char kSupervisedUserCustodianEmail[];

chrome/test/BUILD.gn

@@ -3854,6 +3854,11 @@ test("unit_tests") {
     sources += [ "../browser/notifications/notification_platform_bridge_linux_unittest.cc" ]
   }
 
+  if ((is_linux && !is_chromeos) || is_win) {
+    sources += [ "../browser/feature_engagement_tracker/new_tab/new_tab_tracker_unittest.cc" ]
+    deps += [ "//components/feature_engagement_tracker/test:test_support" ]
+  }
+
   if (is_linux || is_win) {
     sources += [ "../browser/webshare/share_service_impl_unittest.cc" ]
   }

components/feature_engagement_tracker/BUILD.gn

@@ -22,9 +22,6 @@ group("unit_tests") {
 
   deps = [
     "//components/feature_engagement_tracker/internal:unit_tests",
-
-    # TODO(crbug.com/744694 - following line will soon be removed)
-    "//components/feature_engagement_tracker/test:test_support",
   ]
 
   data_deps = [