Vertical tabs p3a (uplift to 1.56.x)

browser/brave_browser_process.h

@@ -65,6 +65,9 @@ class LocalhostPermissionComponent;
 
 namespace misc_metrics {
 class MenuMetrics;
+#if !BUILDFLAG(IS_ANDROID)
+class VerticalTabMetrics;
+#endif
 }  // namespace misc_metrics
 
 namespace request_otr {
@@ -148,6 +151,9 @@ class BraveBrowserProcess {
   virtual brave_ads::ResourceComponent* resource_component() = 0;
   virtual brave::BraveFarblingService* brave_farbling_service() = 0;
   virtual misc_metrics::MenuMetrics* menu_metrics() = 0;
+#if !BUILDFLAG(IS_ANDROID)
+  virtual misc_metrics::VerticalTabMetrics* vertical_tab_metrics() = 0;
+#endif
 };
 
 extern BraveBrowserProcess* g_brave_browser_process;

browser/brave_browser_process_impl.cc

@@ -84,6 +84,7 @@
 #if BUILDFLAG(IS_ANDROID)
 #include "chrome/browser/flags/android/chrome_feature_list.h"
 #else
+#include "brave/browser/misc_metrics/vertical_tab_metrics.h"
 #include "brave/browser/ui/brave_browser_command_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
@@ -142,6 +143,11 @@ BraveBrowserProcessImpl::BraveBrowserProcessImpl(StartupData* startup_data)
 
   // early initialize menu metrics
   menu_metrics();
+
+#if !BUILDFLAG(IS_ANDROID)
+  // early initialize vertical tab metrics
+  vertical_tab_metrics();
+#endif
 }
 
 void BraveBrowserProcessImpl::Init() {
@@ -533,3 +539,16 @@ misc_metrics::MenuMetrics* BraveBrowserProcessImpl::menu_metrics() {
 #endif
   return menu_metrics_.get();
 }
+
+#if !BUILDFLAG(IS_ANDROID)
+misc_metrics::VerticalTabMetrics*
+BraveBrowserProcessImpl::vertical_tab_metrics() {
+#if !BUILDFLAG(IS_ANDROID)
+  if (!vertical_tab_metrics_) {
+    vertical_tab_metrics_ =
+        std::make_unique<misc_metrics::VerticalTabMetrics>(local_state());
+  }
+#endif
+  return vertical_tab_metrics_.get();
+}
+#endif

browser/brave_browser_process_impl.h

@@ -60,6 +60,9 @@ class DebounceComponentInstaller;
 
 namespace misc_metrics {
 class MenuMetrics;
+#if !BUILDFLAG(IS_ANDROID)
+class VerticalTabMetrics;
+#endif
 }  // namespace misc_metrics
 
 namespace request_otr {
@@ -153,6 +156,9 @@ class BraveBrowserProcessImpl : public BraveBrowserProcess,
 #endif
   brave::BraveFarblingService* brave_farbling_service() override;
   misc_metrics::MenuMetrics* menu_metrics() override;
+#if !BUILDFLAG(IS_ANDROID)
+  misc_metrics::VerticalTabMetrics* vertical_tab_metrics() override;
+#endif
 
  private:
   // BrowserProcessImpl overrides:
@@ -230,6 +236,9 @@ class BraveBrowserProcessImpl : public BraveBrowserProcess,
 
   std::unique_ptr<brave::BraveFarblingService> brave_farbling_service_;
   std::unique_ptr<misc_metrics::MenuMetrics> menu_metrics_;
+#if !BUILDFLAG(IS_ANDROID)
+  std::unique_ptr<misc_metrics::VerticalTabMetrics> vertical_tab_metrics_;
+#endif
   std::unique_ptr<brave_ads::BraveStatsHelper> brave_stats_helper_;
 
   SEQUENCE_CHECKER(sequence_checker_);

browser/brave_local_state_prefs.cc

@@ -45,6 +45,7 @@
 #include "brave/browser/ui/webui/new_tab_page/brave_new_tab_message_handler.h"
 
 #if !BUILDFLAG(IS_ANDROID)
+#include "brave/browser/misc_metrics/vertical_tab_metrics.h"
 #include "brave/browser/p3a/p3a_core_metrics.h"
 #include "brave/browser/ui/whats_new/whats_new_util.h"
 #include "chrome/browser/first_run/first_run.h"
@@ -139,6 +140,9 @@ void RegisterLocalStatePrefs(PrefRegistrySimple* registry) {
   misc_metrics::PageMetricsService::RegisterPrefs(registry);
   brave_ads::BraveStatsHelper::RegisterLocalStatePrefs(registry);
   misc_metrics::GeneralBrowserUsage::RegisterPrefs(registry);
+#if !BUILDFLAG(IS_ANDROID)
+  misc_metrics::VerticalTabMetrics::RegisterPrefs(registry);
+#endif
 
   playlist::PlaylistServiceFactory::RegisterLocalStatePrefs(registry);
 }

browser/misc_metrics/sources.gni

@@ -10,6 +10,13 @@ brave_browser_misc_metrics_sources = [
   "//brave/browser/misc_metrics/page_metrics_tab_helper.h",
 ]
 
+if (!is_android) {
+  brave_browser_misc_metrics_sources += [
+    "//brave/browser/misc_metrics/vertical_tab_metrics.cc",
+    "//brave/browser/misc_metrics/vertical_tab_metrics.h",
+  ]
+}
+
 brave_browser_misc_metrics_deps = [
   "//brave/browser:browser_process",
   "//brave/browser/profiles:util",

browser/misc_metrics/vertical_tab_metrics.cc

@@ -0,0 +1,175 @@
+/* Copyright (c) 2023 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+#include "brave/browser/misc_metrics/vertical_tab_metrics.h"
+
+#include <utility>
+
+#include "brave/browser/ui/tabs/brave_tab_prefs.h"
+#include "brave/components/misc_metrics/pref_names.h"
+#include "brave/components/p3a_utils/bucket.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/tabs/tab_group_model.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
+
+namespace misc_metrics {
+
+namespace {
+
+const int kOpenTabsBuckets[] = {1, 5, 10, 50};
+const int kGroupAndPinnedTabsBuckets[] = {2, 5};
+
+const char* GetHistogramNameForCountType(TabCountType count_type) {
+  switch (count_type) {
+    case TabCountType::kOpen:
+      return kVerticalOpenTabsHistogramName;
+    case TabCountType::kGroup:
+      return kVerticalGroupTabsHistogramName;
+    case TabCountType::kPinned:
+      return kVerticalPinnedTabsHistogramName;
+  }
+}
+
+const char* GetStoragePrefNameForCountType(TabCountType count_type) {
+  switch (count_type) {
+    case TabCountType::kOpen:
+      return kMiscMetricsOpenTabsStorage;
+    case TabCountType::kGroup:
+      return kMiscMetricsGroupTabsStorage;
+    case TabCountType::kPinned:
+      return kMiscMetricsPinnedTabsStorage;
+  }
+}
+
+void RecordMaxToHistogramBucket(TabCountType count_type, uint64_t max_value) {
+  const char* histogram_name = GetHistogramNameForCountType(count_type);
+  switch (count_type) {
+    case TabCountType::kOpen:
+      p3a_utils::RecordToHistogramBucket(histogram_name, kOpenTabsBuckets,
+                                         max_value);
+      break;
+    case TabCountType::kGroup:
+    case TabCountType::kPinned:
+      p3a_utils::RecordToHistogramBucket(histogram_name,
+                                         kGroupAndPinnedTabsBuckets, max_value);
+      break;
+  }
+}
+
+}  // namespace
+
+const char kVerticalOpenTabsHistogramName[] = "Brave.VerticalTabs.OpenTabs";
+const char kVerticalGroupTabsHistogramName[] = "Brave.VerticalTabs.GroupTabs";
+const char kVerticalPinnedTabsHistogramName[] = "Brave.VerticalTabs.PinnedTabs";
+
+VerticalTabBrowserMetrics::VerticalTabBrowserMetrics(
+    PrefService* profile_prefs,
+    base::RepeatingClosure change_callback)
+    : profile_prefs_(profile_prefs), change_callback_(change_callback) {
+  for (TabCountType count_type : kAllTabCountTypes) {
+    counts_[count_type] = 0;
+  }
+  pref_change_registrar_.Init(profile_prefs);
+  pref_change_registrar_.Add(
+      brave_tabs::kVerticalTabsEnabled,
+      base::BindRepeating(&VerticalTabBrowserMetrics::UpdateEnabledStatus,
+                          base::Unretained(this)));
+  UpdateEnabledStatus();
+}
+
+VerticalTabBrowserMetrics::~VerticalTabBrowserMetrics() = default;
+
+void VerticalTabBrowserMetrics::OnTabStripModelChanged(
+    TabStripModel* tab_strip_model,
+    const TabStripModelChange& change,
+    const TabStripSelectionChange& selection) {
+  if (!vertical_tabs_enabled_) {
+    return;
+  }
+  counts_[TabCountType::kOpen] = tab_strip_model->count();
+  TabGroupModel* group_model = tab_strip_model->group_model();
+  if (group_model != nullptr) {
+    counts_[TabCountType::kGroup] = group_model->ListTabGroups().size();
+  }
+  counts_[TabCountType::kPinned] = tab_strip_model->IndexOfFirstNonPinnedTab();
+  change_callback_.Run();
+}
+
+size_t VerticalTabBrowserMetrics::GetTabCount(TabCountType count_type) const {
+  if (!vertical_tabs_enabled_) {
+    return 0;
+  }
+  return counts_.at(count_type);
+}
+
+void VerticalTabBrowserMetrics::UpdateEnabledStatus() {
+  vertical_tabs_enabled_ =
+      profile_prefs_->GetBoolean(brave_tabs::kVerticalTabsEnabled);
+}
+
+VerticalTabMetrics::VerticalTabMetrics(PrefService* local_state) {
+  for (TabCountType count_type : kAllTabCountTypes) {
+    global_count_storages_[count_type] = std::make_unique<WeeklyStorage>(
+        local_state, GetStoragePrefNameForCountType(count_type));
+  }
+
+  BrowserList::GetInstance()->AddObserver(this);
+}
+
+VerticalTabMetrics::~VerticalTabMetrics() = default;
+
+void VerticalTabMetrics::RegisterPrefs(PrefRegistrySimple* registry) {
+  for (TabCountType count_type : kAllTabCountTypes) {
+    registry->RegisterListPref(GetStoragePrefNameForCountType(count_type));
+  }
+}
+
+void VerticalTabMetrics::UpdateMetrics() {
+  // Add up tab count totals from all windows
+  base::flat_map<TabCountType, size_t> current_counts;
+  for (const auto& [session_id, browser_metrics] : browser_metrics_) {
+    for (TabCountType count_type : kAllTabCountTypes) {
+      current_counts[count_type] += browser_metrics->GetTabCount(count_type);
+    }
+  }
+  // Report histograms for each tab count type, if the
+  // particular count type is non-zero.
+  for (TabCountType count_type : kAllTabCountTypes) {
+    WeeklyStorage* storage = global_count_storages_[count_type].get();
+    storage->ReplaceTodaysValueIfGreater(current_counts[count_type]);
+    uint64_t max_value = storage->GetHighestValueInWeek();
+    if (max_value > 0) {
+      RecordMaxToHistogramBucket(count_type, max_value);
+    }
+  }
+}
+
+void VerticalTabMetrics::OnBrowserAdded(Browser* browser) {
+  if (!browser->is_type_normal()) {
+    return;
+  }
+  Profile* profile = browser->profile();
+  if (!profile || profile->IsOffTheRecord() || !profile->IsRegularProfile()) {
+    // Do not monitor incognito windows.
+    return;
+  }
+  PrefService* profile_prefs = profile->GetPrefs();
+  CHECK(profile_prefs);
+  SessionID session_id = browser->session_id();
+  browser_metrics_[session_id] = std::make_unique<VerticalTabBrowserMetrics>(
+      profile_prefs, base::BindRepeating(&VerticalTabMetrics::UpdateMetrics,
+                                         base::Unretained(this)));
+  browser->tab_strip_model()->AddObserver(browser_metrics_[session_id].get());
+}
+
+void VerticalTabMetrics::OnBrowserRemoved(Browser* browser) {
+  browser_metrics_.erase(browser->session_id());
+}
+
+}  // namespace misc_metrics

browser/misc_metrics/vertical_tab_metrics.h

@@ -0,0 +1,92 @@
+/* Copyright (c) 2023 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_BROWSER_MISC_METRICS_VERTICAL_TAB_METRICS_H_
+#define BRAVE_BROWSER_MISC_METRICS_VERTICAL_TAB_METRICS_H_
+
+#include <memory>
+
+#include "base/containers/flat_map.h"
+#include "base/memory/raw_ptr.h"
+#include "brave/components/time_period_storage/weekly_storage.h"
+#include "chrome/browser/ui/browser_list_observer.h"
+#include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "components/sessions/core/session_id.h"
+
+class Browser;
+class PrefRegistrySimple;
+class PrefService;
+class TabStripModel;
+
+namespace misc_metrics {
+
+extern const char kVerticalOpenTabsHistogramName[];
+extern const char kVerticalGroupTabsHistogramName[];
+extern const char kVerticalPinnedTabsHistogramName[];
+
+enum class TabCountType {
+  kOpen,
+  kGroup,
+  kPinned,
+};
+
+const TabCountType kAllTabCountTypes[] = {
+    TabCountType::kOpen, TabCountType::kGroup, TabCountType::kPinned};
+
+class VerticalTabBrowserMetrics : public TabStripModelObserver {
+ public:
+  explicit VerticalTabBrowserMetrics(PrefService* profile_prefs,
+                                     base::RepeatingClosure change_callback);
+  ~VerticalTabBrowserMetrics() override;
+
+  VerticalTabBrowserMetrics(const VerticalTabBrowserMetrics&) = delete;
+  VerticalTabBrowserMetrics& operator=(const VerticalTabBrowserMetrics&) =
+      delete;
+
+  // TabStripModelObserver:
+  void OnTabStripModelChanged(
+      TabStripModel* tab_strip_model,
+      const TabStripModelChange& change,
+      const TabStripSelectionChange& selection) override;
+
+  size_t GetTabCount(TabCountType count_type) const;
+
+ private:
+  void UpdateEnabledStatus();
+
+  bool vertical_tabs_enabled_;
+  raw_ptr<PrefService> profile_prefs_;
+  PrefChangeRegistrar pref_change_registrar_;
+  base::flat_map<TabCountType, size_t> counts_;
+  base::RepeatingClosure change_callback_;
+};
+
+class VerticalTabMetrics : public BrowserListObserver {
+ public:
+  explicit VerticalTabMetrics(PrefService* local_state);
+  ~VerticalTabMetrics() override;
+
+  VerticalTabMetrics(const VerticalTabMetrics&) = delete;
+  VerticalTabMetrics& operator=(const VerticalTabMetrics&) = delete;
+
+  static void RegisterPrefs(PrefRegistrySimple* registry);
+
+  void UpdateMetrics();
+
+  // BrowserListObserver:
+  void OnBrowserAdded(Browser* browser) override;
+  void OnBrowserRemoved(Browser* browser) override;
+
+ private:
+  base::flat_map<TabCountType, std::unique_ptr<WeeklyStorage>>
+      global_count_storages_;
+  base::flat_map<SessionID, std::unique_ptr<VerticalTabBrowserMetrics>>
+      browser_metrics_;
+};
+
+}  // namespace misc_metrics
+
+#endif  // BRAVE_BROWSER_MISC_METRICS_VERTICAL_TAB_METRICS_H_