[NTP::SectionOrder] Add category position metric for opened suggestions.

components/ntp_snippets/content_suggestions_metrics.cc

 // Copyright 2016 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 "components/ntp_snippets/content_suggestions_metrics.h"
 
 #include <string>
 #include <type_traits>
 
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/stringprintf.h"
 #include "base/template_util.h"
 
 namespace ntp_snippets {
 namespace metrics {
 
 namespace {
 
 const int kMaxSuggestionsPerCategory = 10;

[finkm, 2017/01/05 16:31:29]

Hmmm ... since we have the more button, a section can have more then 10
suggestions. How does UMA_HISTOGRAM_ENUMERATION(name, sample, enum_max) behave
if sample > enum_max?

[vitaliii, 2017/01/05 17:02:46]

I created a bug and added a TODO (as per our offline discussion).

 const int kMaxSuggestionsTotal = 50;

[finkm, 2017/01/05 16:31:29]

same as above

[vitaliii, 2017/01/05 17:02:46]

same as above.

+const int kMaxCategories = 10;
 
 const char kHistogramCountOnNtpOpened[] =
     "NewTabPage.ContentSuggestions.CountOnNtpOpened";
 const char kHistogramShown[] = "NewTabPage.ContentSuggestions.Shown";
 const char kHistogramShownAge[] = "NewTabPage.ContentSuggestions.ShownAge";
 const char kHistogramShownScore[] = "NewTabPage.ContentSuggestions.ShownScore";
 const char kHistogramOpened[] = "NewTabPage.ContentSuggestions.Opened";
 const char kHistogramOpenedAge[] = "NewTabPage.ContentSuggestions.OpenedAge";
+const char kHistogramOpenedCategoryPosition[] =
+    "NewTabPage.ContentSuggestions.OpenedCategoryPosition";
 const char kHistogramOpenedScore[] =
     "NewTabPage.ContentSuggestions.OpenedScore";
 const char kHistogramOpenDisposition[] =
     "NewTabPage.ContentSuggestions.OpenDisposition";
 const char kHistogramMenuOpened[] = "NewTabPage.ContentSuggestions.MenuOpened";
 const char kHistogramMenuOpenedAge[] =
     "NewTabPage.ContentSuggestions.MenuOpenedAge";
 const char kHistogramMenuOpenedScore[] =
     "NewTabPage.ContentSuggestions.MenuOpenedScore";
 const char kHistogramDismissedUnvisited[] =
@@ skipping 183 matching lines @@
                          kWeekdayNames[now_exploded.day_of_week]));
   UmaHistogramEnumeration(histogram_name, bucket, kNumBuckets);
 
   UMA_HISTOGRAM_ENUMERATION(kHistogramArticlesUsageTimeLocal, bucket,
                             kNumBuckets);
 
   base::RecordAction(
       base::UserMetricsAction("NewTabPage_ContentSuggestions_ArticlesUsage"));
 }
 
+int GetCategoryPosition(
+    Category category,
+    const ntp_snippets::ContentSuggestionsService* service) {
+  std::vector<Category> ordered_categories = service->GetCategories();
+  DCHECK(base::ContainsValue(ordered_categories, category));
+  auto it =
+      std::find(ordered_categories.begin(), ordered_categories.end(), category);
+  return it - ordered_categories.begin();
+}
+
 }  // namespace
 
 void OnPageShown(
     const std::vector<std::pair<Category, int>>& suggestions_per_category) {
   int suggestions_total = 0;
   for (const std::pair<Category, int>& item : suggestions_per_category) {
     LogCategoryHistogramEnumeration(kHistogramCountOnNtpOpened, item.first,
                                     item.second, kMaxSuggestionsPerCategory);
     suggestions_total += item.second;
   }
 
   UMA_HISTOGRAM_ENUMERATION(kHistogramCountOnNtpOpened, suggestions_total,
                             kMaxSuggestionsTotal);
 }
 
 void OnSuggestionShown(int global_position,
                        Category category,
-                       int category_position,
+                       int position_in_category,
                        base::Time publish_date,
                        base::Time last_background_fetch_time,
                        float score) {
   UMA_HISTOGRAM_ENUMERATION(kHistogramShown, global_position,
                             kMaxSuggestionsTotal);
-  LogCategoryHistogramEnumeration(kHistogramShown, category, category_position,
+  LogCategoryHistogramEnumeration(kHistogramShown, category,
+                                  position_in_category,
                                   kMaxSuggestionsPerCategory);
 
   base::TimeDelta age = base::Time::Now() - publish_date;
   LogCategoryHistogramAge(kHistogramShownAge, category, age);
 
   LogCategoryHistogramScore(kHistogramShownScore, category, score);
 
   // TODO(markusheintz): Discuss whether the code below should be move into a
   // separate method called OnSuggestionsListShown.
   // When the first of the articles suggestions is shown, then we count this as
   // a single usage of content suggestions.
   if (category.IsKnownCategory(KnownCategories::ARTICLES) &&
-      category_position == 0) {
+      position_in_category == 0) {
     RecordContentSuggestionsUsage();
 
     // Records the time since the last background fetch of the remote content
     // suggestions.
     UMA_HISTOGRAM_CUSTOM_TIMES(
         kHistogramContentSuggestionsTimeSinceLastBackgroundFetch,
         base::Time::Now() - last_background_fetch_time,
         base::TimeDelta::FromSeconds(1), base::TimeDelta::FromDays(7),
         /*bucket_count=*/100);
   }
 }
 
-void OnSuggestionOpened(int global_position,
+void OnSuggestionOpened(const ContentSuggestionsService* service,
+                        int global_position,
                         Category category,
-                        int category_position,
+                        int position_in_category,
                         base::Time publish_date,
                         float score,
                         WindowOpenDisposition disposition) {
+  const int category_position = GetCategoryPosition(category, service);
+  UMA_HISTOGRAM_ENUMERATION(kHistogramOpenedCategoryPosition, category_position,
+                            kMaxCategories);
+  LogCategoryHistogramEnumeration(kHistogramOpenedCategoryPosition, category,
+                                  category_position, kMaxCategories);
+
   UMA_HISTOGRAM_ENUMERATION(kHistogramOpened, global_position,
                             kMaxSuggestionsTotal);
-  LogCategoryHistogramEnumeration(kHistogramOpened, category, category_position,
+  LogCategoryHistogramEnumeration(kHistogramOpened, category,
+                                  position_in_category,
                                   kMaxSuggestionsPerCategory);
 
   base::TimeDelta age = base::Time::Now() - publish_date;
   LogCategoryHistogramAge(kHistogramOpenedAge, category, age);
 
   LogCategoryHistogramScore(kHistogramOpenedScore, category, score);
 
   UMA_HISTOGRAM_ENUMERATION(
       kHistogramOpenDisposition, static_cast<int>(disposition),
       static_cast<int>(WindowOpenDisposition::MAX_VALUE) + 1);
   LogCategoryHistogramEnumeration(
       kHistogramOpenDisposition, category, static_cast<int>(disposition),
       static_cast<int>(WindowOpenDisposition::MAX_VALUE) + 1);
 
   if (category.IsKnownCategory(KnownCategories::ARTICLES)) {
     RecordContentSuggestionsUsage();
   }
 }
 
 void OnSuggestionMenuOpened(int global_position,
                             Category category,
-                            int category_position,
+                            int position_in_category,
                             base::Time publish_date,
                             float score) {
   UMA_HISTOGRAM_ENUMERATION(kHistogramMenuOpened, global_position,
                             kMaxSuggestionsTotal);
   LogCategoryHistogramEnumeration(kHistogramMenuOpened, category,
-                                  category_position,
+                                  position_in_category,
                                   kMaxSuggestionsPerCategory);
 
   base::TimeDelta age = base::Time::Now() - publish_date;
   LogCategoryHistogramAge(kHistogramMenuOpenedAge, category, age);
 
   LogCategoryHistogramScore(kHistogramMenuOpenedScore, category, score);
 }
 
 void OnSuggestionDismissed(int global_position,
                            Category category,
-                           int category_position,
+                           int position_in_category,
                            bool visited) {
   if (visited) {
     UMA_HISTOGRAM_ENUMERATION(kHistogramDismissedVisited, global_position,
                               kMaxSuggestionsTotal);
     LogCategoryHistogramEnumeration(kHistogramDismissedVisited, category,
-                                    category_position,
+                                    position_in_category,
                                     kMaxSuggestionsPerCategory);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kHistogramDismissedUnvisited, global_position,
                               kMaxSuggestionsTotal);
     LogCategoryHistogramEnumeration(kHistogramDismissedUnvisited, category,
-                                    category_position,
+                                    position_in_category,
                                     kMaxSuggestionsPerCategory);
   }
 }
 
 void OnSuggestionTargetVisited(Category category, base::TimeDelta visit_time) {
   LogCategoryHistogramLongTimes(kHistogramVisitDuration, category, visit_time);
 }
 
 void OnMoreButtonShown(Category category, int position) {
   // The "more" card can appear in addition to the actual suggestions, so add
@@ skipping 10 matching lines @@
 }
 
 void OnCategoryDismissed(Category category) {
   UMA_HISTOGRAM_ENUMERATION(kHistogramCategoryDismissed,
                             static_cast<int>(GetHistogramCategory(category)),
                             static_cast<int>(HistogramCategories::COUNT));
 }
 
 }  // namespace metrics
 }  // namespace ntp_snippets