[Power ML] Move ukm logging bucketization to a helper file.

We will need the same bucketization during inference. Hence move common code to
the helper file to avoid code duplication and also to ensure consistency.

Bug: 862461
Change-Id: I75e53c6a409ce7f61383637b783158abd7f59e32
Reviewed-on: https://chromium-review.googlesource.com/1154607
Commit-Queue: Jia Meng <jiameng@chromium.org>
Reviewed-by: Michael Martis <martis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#580798}

chrome/browser/chromeos/BUILD.gn

@@ -1540,6 +1540,8 @@ source_set("chromeos") {
     "power/ml/user_activity_manager.cc",
     "power/ml/user_activity_manager.h",
     "power/ml/user_activity_ukm_logger.h",
+    "power/ml/user_activity_ukm_logger_helpers.cc",
+    "power/ml/user_activity_ukm_logger_helpers.h",
     "power/ml/user_activity_ukm_logger_impl.cc",
     "power/ml/user_activity_ukm_logger_impl.h",
     "power/power_data_collector.cc",
@@ -2176,6 +2178,7 @@ source_set("unit_tests") {
     "power/ml/real_boot_clock_unittest.cc",
     "power/ml/recent_events_counter_unittest.cc",
     "power/ml/user_activity_manager_unittest.cc",
+    "power/ml/user_activity_ukm_logger_helpers_unittest.cc",
     "power/ml/user_activity_ukm_logger_unittest.cc",
     "power/power_data_collector_unittest.cc",
     "power/power_metrics_reporter_unittest.cc",

chrome/browser/chromeos/power/ml/adaptive_screen_brightness_ukm_logger_impl.cc

@@ -4,11 +4,12 @@
 
 #include "chrome/browser/chromeos/power/ml/adaptive_screen_brightness_ukm_logger_impl.h"
 
+#include <array>
 #include <cmath>
 
 #include "base/logging.h"
 #include "chrome/browser/chromeos/power/ml/screen_brightness_event.pb.h"
-#include "chrome/browser/chromeos/power/ml/user_activity_ukm_logger_impl.h"
+#include "chrome/browser/chromeos/power/ml/user_activity_ukm_logger_helpers.h"
 #include "services/metrics/public/cpp/ukm_builders.h"
 #include "services/metrics/public/cpp/ukm_recorder.h"
 #include "services/metrics/public/cpp/ukm_source_id.h"
@@ -21,20 +22,16 @@ namespace {
 
 constexpr int kSecondsPerHour = 3600;
 
-constexpr UserActivityUkmLoggerImpl::Bucket kBatteryPercentBuckets[] = {
-    {100, 5}};
+constexpr std::array<Bucket, 1> kBatteryPercentBuckets = {{{100, 5}}};
 
-constexpr UserActivityUkmLoggerImpl::Bucket kUserInputEventBuckets[] = {
-    {100, 1},
-    {1000, 100},
-    {10000, 1000}};
+constexpr std::array<Bucket, 3> kUserInputEventBuckets = {
+    {{100, 1}, {1000, 100}, {10000, 1000}}};
 
-constexpr UserActivityUkmLoggerImpl::Bucket kRecentTimeActiveBuckets[] =
-    {{60, 1}, {600, 60}, {1200, 300}, {3600, 600}, {18000, 1800}};
+constexpr std::array<Bucket, 5> kRecentTimeActiveBuckets = {
+    {{60, 1}, {600, 60}, {1200, 300}, {3600, 600}, {18000, 1800}}};
 
-constexpr UserActivityUkmLoggerImpl::Bucket kTimeSinceLastEventBuckets[] = {
-    {60, 1},
-    {600, 60}};
+constexpr std::array<Bucket, 2> kTimeSinceLastEventBuckets = {
+    {{60, 1}, {600, 60}}};
 
 }  // namespace
 
@@ -64,31 +61,23 @@ void AdaptiveScreenBrightnessUkmLoggerImpl::LogActivity(
   }
 
   if (activity_data.has_num_recent_mouse_events()) {
-    ukm_screen_brightness.SetNumRecentMouseEvents(
-        UserActivityUkmLoggerImpl::Bucketize(
-            activity_data.num_recent_mouse_events(), kUserInputEventBuckets,
-            base::size(kUserInputEventBuckets)));
+    ukm_screen_brightness.SetNumRecentMouseEvents(Bucketize(
+        activity_data.num_recent_mouse_events(), kUserInputEventBuckets));
   }
 
   if (activity_data.has_num_recent_key_events()) {
-    ukm_screen_brightness.SetNumRecentKeyEvents(
-        UserActivityUkmLoggerImpl::Bucketize(
-            activity_data.num_recent_key_events(), kUserInputEventBuckets,
-            base::size(kUserInputEventBuckets)));
+    ukm_screen_brightness.SetNumRecentKeyEvents(Bucketize(
+        activity_data.num_recent_key_events(), kUserInputEventBuckets));
   }
 
   if (activity_data.has_num_recent_stylus_events()) {
-    ukm_screen_brightness.SetNumRecentStylusEvents(
-        UserActivityUkmLoggerImpl::Bucketize(
-            activity_data.num_recent_stylus_events(), kUserInputEventBuckets,
-            base::size(kUserInputEventBuckets)));
+    ukm_screen_brightness.SetNumRecentStylusEvents(Bucketize(
+        activity_data.num_recent_stylus_events(), kUserInputEventBuckets));
   }
 
   if (activity_data.has_num_recent_touch_events()) {
-    ukm_screen_brightness.SetNumRecentTouchEvents(
-        UserActivityUkmLoggerImpl::Bucketize(
-            activity_data.num_recent_touch_events(), kUserInputEventBuckets,
-            base::size(kUserInputEventBuckets)));
+    ukm_screen_brightness.SetNumRecentTouchEvents(Bucketize(
+        activity_data.num_recent_touch_events(), kUserInputEventBuckets));
   }
 
   if (activity_data.has_last_activity_time_sec()) {
@@ -97,10 +86,8 @@ void AdaptiveScreenBrightnessUkmLoggerImpl::LogActivity(
   }
 
   if (activity_data.has_recent_time_active_sec()) {
-    ukm_screen_brightness.SetRecentTimeActiveSec(
-        UserActivityUkmLoggerImpl::Bucketize(
-            activity_data.recent_time_active_sec(), kRecentTimeActiveBuckets,
-            base::size(kRecentTimeActiveBuckets)));
+    ukm_screen_brightness.SetRecentTimeActiveSec(Bucketize(
+        activity_data.recent_time_active_sec(), kRecentTimeActiveBuckets));
   }
 
   if (activity_data.has_is_video_playing()) {
@@ -114,10 +101,8 @@ void AdaptiveScreenBrightnessUkmLoggerImpl::LogActivity(
   }
 
   if (env_data.has_battery_percent()) {
-    ukm_screen_brightness.SetBatteryPercent(
-        UserActivityUkmLoggerImpl::Bucketize(
-            std::floor(env_data.battery_percent()), kBatteryPercentBuckets,
-            base::size(kBatteryPercentBuckets)));
+    ukm_screen_brightness.SetBatteryPercent(Bucketize(
+        std::floor(env_data.battery_percent()), kBatteryPercentBuckets));
   }
 
   if (env_data.has_device_mode()) {
@@ -211,10 +196,8 @@ void AdaptiveScreenBrightnessUkmLoggerImpl::LogActivity(
   }
 
   if (event.has_time_since_last_event_sec()) {
-    ukm_screen_brightness.SetTimeSinceLastEventSec(
-        UserActivityUkmLoggerImpl::Bucketize(
-            event.time_since_last_event_sec(), kTimeSinceLastEventBuckets,
-            base::size(kTimeSinceLastEventBuckets)));
+    ukm_screen_brightness.SetTimeSinceLastEventSec(Bucketize(
+        event.time_since_last_event_sec(), kTimeSinceLastEventBuckets));
   }
 
   ukm::UkmRecorder* const ukm_recorder = ukm::UkmRecorder::Get();

chrome/browser/chromeos/power/ml/user_activity_ukm_logger_helpers.cc

+// Copyright 2018 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/chromeos/power/ml/user_activity_ukm_logger_helpers.h"
+
+#include <array>
+
+#include "base/stl_util.h"
+
+namespace chromeos {
+namespace power {
+namespace ml {
+
+namespace {
+
+constexpr std::array<Bucket, 1> kBatteryPercentBuckets = {{{100, 5}}};
+
+constexpr std::array<Bucket, 3> kEventLogDurationBuckets = {
+    {{600, 1}, {1200, 10}, {1800, 20}}};
+
+constexpr std::array<Bucket, 3> kUserInputEventBuckets = {
+    {{100, 1}, {1000, 100}, {10000, 1000}}};
+
+constexpr std::array<Bucket, 4> kRecentVideoPlayingTimeBuckets = {
+    {{60, 1}, {1200, 300}, {3600, 600}, {18000, 1800}}};
+
+constexpr std::array<Bucket, 5> kTimeSinceLastVideoEndedBuckets = {
+    {{60, 1}, {600, 60}, {1200, 300}, {3600, 600}, {18000, 1800}}};
+
+}  // namespace
+
+std::map<std::string, int>
+UserActivityUkmLoggerBucketizer::BucketizeUserActivityEventFeatures(
+    const UserActivityEvent::Features& features) {
+  std::map<std::string, int> buckets;
+
+  if (features.has_battery_percent()) {
+    buckets[kBatteryPercent] = Bucketize(std::floor(features.battery_percent()),
+                                         kBatteryPercentBuckets);
+  }
+
+  if (features.has_key_events_in_last_hour()) {
+    buckets[kKeyEventsInLastHour] =
+        Bucketize(features.key_events_in_last_hour(), kUserInputEventBuckets);
+  }
+
+  buckets[kLastActivityTime] =
+      std::floor(features.last_activity_time_sec() / 3600);
+
+  if (features.has_last_user_activity_time_sec()) {
+    buckets[kLastUserActivityTime] =
+        std::floor(features.last_user_activity_time_sec() / 3600);
+  }
+
+  if (features.has_mouse_events_in_last_hour()) {
+    buckets[kMouseEventsInLastHour] =
+        Bucketize(features.mouse_events_in_last_hour(), kUserInputEventBuckets);
+  }
+
+  if (features.has_video_playing_time_sec()) {
+    buckets[kRecentVideoPlayingTime] = Bucketize(
+        features.video_playing_time_sec(), kRecentVideoPlayingTimeBuckets);
+  }
+
+  if (features.has_time_since_video_ended_sec()) {
+    buckets[kTimeSinceLastVideoEnded] = Bucketize(
+        features.time_since_video_ended_sec(), kTimeSinceLastVideoEndedBuckets);
+  }
+
+  if (features.has_touch_events_in_last_hour()) {
+    buckets[kTouchEventsInLastHour] =
+        Bucketize(features.touch_events_in_last_hour(), kUserInputEventBuckets);
+  }
+
+  return buckets;
+}
+
+std::map<std::string, int>
+UserActivityUkmLoggerBucketizer::BucketizeUserActivityEventData(
+    const UserActivityEvent& event) {
+  std::map<std::string, int> buckets =
+      BucketizeUserActivityEventFeatures(event.features());
+
+  if (event.event().has_log_duration_sec()) {
+    buckets[kEventLogDuration] =
+        Bucketize(event.event().log_duration_sec(), kEventLogDurationBuckets);
+  }
+  return buckets;
+}
+
+}  // namespace ml
+}  // namespace power
+}  // namespace chromeos

chrome/browser/chromeos/power/ml/user_activity_ukm_logger_helpers.h

+// Copyright 2018 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_CHROMEOS_POWER_ML_USER_ACTIVITY_UKM_LOGGER_HELPERS_H_
+#define CHROME_BROWSER_CHROMEOS_POWER_ML_USER_ACTIVITY_UKM_LOGGER_HELPERS_H_
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+#include <map>
+#include <string>
+
+#include "chrome/browser/chromeos/power/ml/user_activity_event.pb.h"
+
+namespace chromeos {
+namespace power {
+namespace ml {
+
+// Metrics below are bucketized.
+constexpr char kBatteryPercent[] = "BatteryPercent";
+constexpr char kEventLogDuration[] = "EventLogDuration";
+constexpr char kKeyEventsInLastHour[] = "KeyEventsInLastHour";
+constexpr char kLastActivityTime[] = "LastActivityTime";
+constexpr char kLastUserActivityTime[] = "LastUserActivityTime";
+constexpr char kMouseEventsInLastHour[] = "MouseEventsInLastHour";
+constexpr char kRecentVideoPlayingTime[] = "RecentVideoPlayingTime";
+constexpr char kTimeSinceLastVideoEnded[] = "TimeSinceLastVideoEnded";
+constexpr char kTouchEventsInLastHour[] = "TouchEventsInLastHour";
+
+// TODO(jiameng): both Bucket and Bucketize are meant for user activity logging,
+// but it's currently used by adaptive brightness. Need to refactor by either
+// moving these two items to a more common lib or having a helper file for
+// adaptive brightness as the two projects are likely to diverge.
+
+// Both |boundary_end| and |rounding| must be positive.
+struct Bucket {
+  int boundary_end;
+  int rounding;
+};
+
+// Bucketize |original_value| using given |buckets|, which is an array of
+// Bucket and must be sorted in ascending order of |boundary_end|.
+// |original_value| must be non-negative. An example of |buckets| is
+// {{60, 1}, {300, 10}, {600, 20}}. This function rounds |original_value| down
+// to the nearest |bucket.rounding|, where |bucket| is the first entry in
+// |buckets| with |bucket.boundary_end| > |original_value|.
+// If |original_value| is greater than all |boundary_end|, the function
+// returns the largest |boundary_end|. Using the above |buckets| example, the
+// function will return 30 if |original_value| = 30, and 290 if
+// |original_value| = 299.
+template <size_t N>
+int Bucketize(int original_value, const std::array<Bucket, N>& buckets) {
+  DCHECK_GE(original_value, 0);
+  DCHECK(!buckets.empty());
+  for (const auto& bucket : buckets) {
+    if (original_value < bucket.boundary_end) {
+      return bucket.rounding * (original_value / bucket.rounding);
+    }
+  }
+  return buckets.back().boundary_end;
+}
+
+class UserActivityUkmLoggerBucketizer {
+ public:
+  // Bucketizes features if they are present. Returns a
+  // feature->bucketized_value map.
+  static std::map<std::string, int> BucketizeUserActivityEventFeatures(
+      const UserActivityEvent::Features& features);
+
+  // Bucketizes features and also EventLogDuration.
+  static std::map<std::string, int> BucketizeUserActivityEventData(
+      const UserActivityEvent& event);
+
+ private:
+  UserActivityUkmLoggerBucketizer() = delete;
+  DISALLOW_COPY_AND_ASSIGN(UserActivityUkmLoggerBucketizer);
+};
+
+}  // namespace ml
+}  // namespace power
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_POWER_ML_USER_ACTIVITY_UKM_LOGGER_HELPERS_H_

chrome/browser/chromeos/power/ml/user_activity_ukm_logger_helpers_unittest.cc

+// Copyright 2018 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/chromeos/power/ml/user_activity_ukm_logger_helpers.h"
+
+#include <array>
+#include <memory>
+
+#include "base/stl_util.h"
+#include "chrome/browser/chromeos/power/ml/user_activity_event.pb.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace power {
+namespace ml {
+
+TEST(UserActivityUkmLoggerBucketizerTest, BucketEveryFivePercents) {
+  constexpr std::array<int, 4> original_values = {{0, 14, 15, 100}};
+  constexpr std::array<int, 4> results = {{0, 10, 15, 100}};
+  constexpr std::array<Bucket, 1> buckets = {{{100, 5}}};
+
+  for (size_t i = 0; i < original_values.size(); ++i) {
+    EXPECT_EQ(results[i], Bucketize(original_values[i], buckets));
+  }
+}
+
+TEST(UserActivityUkmLoggerBucketizerTest, Bucketize) {
+  constexpr std::array<int, 14> original_values = {
+      {0, 18, 59, 60, 62, 69, 72, 299, 300, 306, 316, 599, 600, 602}};
+  constexpr std::array<int, 14> results = {
+      {0, 18, 59, 60, 60, 60, 70, 290, 300, 300, 300, 580, 600, 600}};
+  constexpr std::array<Bucket, 3> buckets = {{{60, 1}, {300, 10}, {600, 20}}};
+  for (size_t i = 0; i < original_values.size(); ++i) {
+    EXPECT_EQ(results[i], Bucketize(original_values[i], buckets));
+  }
+}
+
+TEST(UserActivityUkmLoggerBucketizerTest, BucketizeUserActivityEventData) {
+  UserActivityEvent user_activity_event;
+  UserActivityEvent::Event& event = *user_activity_event.mutable_event();
+  event.set_log_duration_sec(395);
+  event.set_reason(UserActivityEvent::Event::USER_ACTIVITY);
+  event.set_type(UserActivityEvent::Event::REACTIVATE);
+  event.set_screen_dim_occurred(true);
+  event.set_screen_off_occurred(true);
+  event.set_screen_lock_occurred(true);
+
+  // In the order of metrics names in ukm.
+  UserActivityEvent::Features& features =
+      *user_activity_event.mutable_features();
+  features.set_battery_percent(96.0);
+  features.set_device_management(UserActivityEvent::Features::UNMANAGED);
+  features.set_device_mode(UserActivityEvent::Features::CLAMSHELL);
+  features.set_device_type(UserActivityEvent::Features::CHROMEBOOK);
+  features.set_last_activity_day(UserActivityEvent::Features::MON);
+  features.set_last_activity_time_sec(7300);
+  features.set_last_user_activity_time_sec(3800);
+  features.set_key_events_in_last_hour(20000);
+  features.set_recent_time_active_sec(10);
+  features.set_previous_negative_actions_count(2);
+  features.set_previous_positive_actions_count(1);
+  features.set_video_playing_time_sec(800);
+  features.set_on_to_dim_sec(100);
+  features.set_dim_to_screen_off_sec(200);
+  features.set_screen_dimmed_initially(false);
+  features.set_screen_locked_initially(false);
+  features.set_screen_off_initially(false);
+  features.set_time_since_last_mouse_sec(100);
+  features.set_time_since_last_touch_sec(311);
+  features.set_time_since_video_ended_sec(400);
+  features.set_mouse_events_in_last_hour(89);
+  features.set_touch_events_in_last_hour(1890);
+
+  std::map<std::string, int> buckets =
+      UserActivityUkmLoggerBucketizer::BucketizeUserActivityEventData(
+          user_activity_event);
+  EXPECT_EQ(9u, buckets.size());
+  EXPECT_EQ(95, buckets["BatteryPercent"]);
+  EXPECT_EQ(395, buckets["EventLogDuration"]);
+  EXPECT_EQ(10000, buckets["KeyEventsInLastHour"]);
+  EXPECT_EQ(2, buckets["LastActivityTime"]);
+  EXPECT_EQ(1, buckets["LastUserActivityTime"]);
+  EXPECT_EQ(89, buckets["MouseEventsInLastHour"]);
+  EXPECT_EQ(600, buckets["RecentVideoPlayingTime"]);
+  EXPECT_EQ(360, buckets["TimeSinceLastVideoEnded"]);
+  EXPECT_EQ(1000, buckets["TouchEventsInLastHour"]);
+}
+
+}  // namespace ml
+}  // namespace power
+}  // namespace chromeos

chrome/browser/chromeos/power/ml/user_activity_ukm_logger_impl.cc

@@ -6,6 +6,7 @@
 
 #include "chrome/browser/chromeos/power/ml/user_activity_event.pb.h"
 #include "chrome/browser/chromeos/power/ml/user_activity_manager.h"
+#include "chrome/browser/chromeos/power/ml/user_activity_ukm_logger_helpers.h"
 #include "chrome/browser/chromeos/power/ml/user_activity_ukm_logger_impl.h"
 #include "content/public/browser/web_contents.h"
 #include "services/metrics/public/cpp/ukm_builders.h"
@@ -15,52 +16,17 @@ namespace chromeos {
 namespace power {
 namespace ml {
 
-namespace {
-
-constexpr UserActivityUkmLoggerImpl::Bucket kBatteryPercentBuckets[] = {
-    {100, 5}};
-
-constexpr UserActivityUkmLoggerImpl::Bucket kEventLogDurationBuckets[] = {
-    {600, 1},
-    {1200, 10},
-    {1800, 20}};
-
-constexpr UserActivityUkmLoggerImpl::Bucket kUserInputEventBuckets[] = {
-    {100, 1},
-    {1000, 100},
-    {10000, 1000}};
-
-constexpr UserActivityUkmLoggerImpl::Bucket kRecentVideoPlayingTimeBuckets[] = {
-    {60, 1},
-    {1200, 300},
-    {3600, 600},
-    {18000, 1800}};
-
-constexpr UserActivityUkmLoggerImpl::Bucket kTimeSinceLastVideoEndedBuckets[] =
-    {{60, 1}, {600, 60}, {1200, 300}, {3600, 600}, {18000, 1800}};
-
-}  // namespace
-
-int UserActivityUkmLoggerImpl::Bucketize(int original_value,
-                                         const Bucket* buckets,
-                                         size_t num_buckets) {
-  DCHECK_GE(original_value, 0);
-  DCHECK(buckets);
-  for (size_t i = 0; i < num_buckets; ++i) {
-    const Bucket& bucket = buckets[i];
-    if (original_value < bucket.boundary_end) {
-      return bucket.rounding * (original_value / bucket.rounding);
-    }
-  }
-  return buckets[num_buckets - 1].boundary_end;
-}
-
 UserActivityUkmLoggerImpl::UserActivityUkmLoggerImpl()
     : ukm_recorder_(ukm::UkmRecorder::Get()) {}
 
 UserActivityUkmLoggerImpl::~UserActivityUkmLoggerImpl() = default;
 
 void UserActivityUkmLoggerImpl::LogActivity(const UserActivityEvent& event) {
+  // Bucketize the features defined in UserActivityUkmLoggerBucketizer if
+  // present.
+  std::map<std::string, int> buckets =
+      UserActivityUkmLoggerBucketizer::BucketizeUserActivityEventData(event);
+
   DCHECK(ukm_recorder_);
   ukm::SourceId source_id = ukm_recorder_->GetNewSourceID();
   ukm::builders::UserActivity user_activity(source_id);
@@ -70,17 +36,13 @@ void UserActivityUkmLoggerImpl::LogActivity(const UserActivityEvent& event) {
   user_activity.SetSequenceId(next_sequence_id_++)
       .SetDeviceMode(features.device_mode())
       .SetDeviceType(features.device_type())
-      .SetEventLogDuration(Bucketize(event.event().log_duration_sec(),
-                                     kEventLogDurationBuckets,
-                                     base::size(kEventLogDurationBuckets)))
+      .SetEventLogDuration(buckets[kEventLogDuration])
       .SetEventReason(event.event().reason())
       .SetEventType(event.event().type())
       .SetLastActivityDay(features.last_activity_day())
-      .SetLastActivityTime(std::floor(features.last_activity_time_sec() / 3600))
+      .SetLastActivityTime(buckets[kLastActivityTime])
       .SetRecentTimeActive(features.recent_time_active_sec())
-      .SetRecentVideoPlayingTime(Bucketize(
-          features.video_playing_time_sec(), kRecentVideoPlayingTimeBuckets,
-          base::size(kRecentVideoPlayingTimeBuckets)))
+      .SetRecentVideoPlayingTime(buckets[kRecentVideoPlayingTime])
       .SetScreenDimmedInitially(features.screen_dimmed_initially())
       .SetScreenDimOccurred(event.event().screen_dim_occurred())
       .SetScreenLockedInitially(features.screen_locked_initially())
@@ -96,8 +58,7 @@ void UserActivityUkmLoggerImpl::LogActivity(const UserActivityEvent& event) {
   }
 
   if (features.has_last_user_activity_time_sec()) {
-    user_activity.SetLastUserActivityTime(
-        std::floor(features.last_user_activity_time_sec() / 3600));
+    user_activity.SetLastUserActivityTime(buckets[kLastUserActivityTime]);
   }
   if (features.has_time_since_last_key_sec()) {
     user_activity.SetTimeSinceLastKey(features.time_since_last_key_sec());
@@ -114,9 +75,7 @@ void UserActivityUkmLoggerImpl::LogActivity(const UserActivityEvent& event) {
   }
 
   if (features.has_battery_percent()) {
-    user_activity.SetBatteryPercent(
-        Bucketize(std::floor(features.battery_percent()),
-                  kBatteryPercentBuckets, base::size(kBatteryPercentBuckets)));
+    user_activity.SetBatteryPercent(buckets[kBatteryPercent]);
   }
 
   if (features.has_device_management()) {
@@ -124,27 +83,19 @@ void UserActivityUkmLoggerImpl::LogActivity(const UserActivityEvent& event) {
   }
 
   if (features.has_time_since_video_ended_sec()) {
-    user_activity.SetTimeSinceLastVideoEnded(Bucketize(
-        features.time_since_video_ended_sec(), kTimeSinceLastVideoEndedBuckets,
-        base::size(kTimeSinceLastVideoEndedBuckets)));
+    user_activity.SetTimeSinceLastVideoEnded(buckets[kTimeSinceLastVideoEnded]);
   }
 
   if (features.has_key_events_in_last_hour()) {
-    user_activity.SetKeyEventsInLastHour(
-        Bucketize(features.key_events_in_last_hour(), kUserInputEventBuckets,
-                  base::size(kUserInputEventBuckets)));
+    user_activity.SetKeyEventsInLastHour(buckets[kKeyEventsInLastHour]);
   }
 
   if (features.has_mouse_events_in_last_hour()) {
-    user_activity.SetMouseEventsInLastHour(
-        Bucketize(features.mouse_events_in_last_hour(), kUserInputEventBuckets,
-                  base::size(kUserInputEventBuckets)));
+    user_activity.SetMouseEventsInLastHour(buckets[kMouseEventsInLastHour]);
   }
 
   if (features.has_touch_events_in_last_hour()) {
-    user_activity.SetTouchEventsInLastHour(
-        Bucketize(features.touch_events_in_last_hour(), kUserInputEventBuckets,
-                  base::size(kUserInputEventBuckets)));
+    user_activity.SetTouchEventsInLastHour(buckets[kTouchEventsInLastHour]);
   }
 
   user_activity

chrome/browser/chromeos/power/ml/user_activity_ukm_logger_impl.h

@@ -17,25 +17,6 @@ class UserActivityEvent;
 
 class UserActivityUkmLoggerImpl : public UserActivityUkmLogger {
  public:
-  // Both |boundary_end| and |rounding| must be positive.
-  struct Bucket {
-    int boundary_end;
-    int rounding;
-  };
-
-  // Bucketize |original_value| using given |buckets|, which is an array of
-  // Bucket and must be sorted in ascending order of |boundary_end|.
-  // |original_value| must be non-negative. An example of |buckets| is
-  // {{60, 1}, {300, 10}, {600, 20}}. This function looks for the first
-  // |boundary_end| > |original_value| and bucket it to the nearest |rounding|.
-  // If |original_value| is greater than all |boundary_end|, the function
-  // returns the largest |boundary_end|. Using the above |buckets| example, the
-  // function will return 30 if |original_value| = 30, and 290 if
-  // |original_value| = 299.
-  static int Bucketize(int original_value,
-                       const Bucket* buckets,
-                       size_t num_buckets);
-
   UserActivityUkmLoggerImpl();
   ~UserActivityUkmLoggerImpl() override;
 

chrome/browser/chromeos/power/ml/user_activity_ukm_logger_unittest.cc

@@ -149,30 +149,6 @@ class UserActivityUkmLoggerTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(UserActivityUkmLoggerTest);
 };
 
-TEST_F(UserActivityUkmLoggerTest, BucketEveryFivePercents) {
-  const std::vector<int> original_values = {0, 14, 15, 100};
-  const std::vector<int> results = {0, 10, 15, 100};
-  constexpr UserActivityUkmLoggerImpl::Bucket buckets[] = {{100, 5}};
-
-  for (size_t i = 0; i < original_values.size(); ++i) {
-    EXPECT_EQ(results[i], UserActivityUkmLoggerImpl::Bucketize(
-                              original_values[i], buckets, arraysize(buckets)));
-  }
-}
-
-TEST_F(UserActivityUkmLoggerTest, Bucketize) {
-  const std::vector<int> original_values = {0,   18,  59,  60,  62,  69,  72,
-                                            299, 300, 306, 316, 599, 600, 602};
-  constexpr UserActivityUkmLoggerImpl::Bucket buckets[] = {
-      {60, 1}, {300, 10}, {600, 20}};
-  const std::vector<int> results = {0,   18,  59,  60,  60,  60,  70,
-                                    290, 300, 300, 300, 580, 600, 600};
-  for (size_t i = 0; i < original_values.size(); ++i) {
-    EXPECT_EQ(results[i], UserActivityUkmLoggerImpl::Bucketize(
-                              original_values[i], buckets, arraysize(buckets)));
-  }
-}
-
 TEST_F(UserActivityUkmLoggerTest, BasicLogging) {
   auto user_activity_event = user_activity_event_;
   UserActivityEvent::Features* features =