Clean old smart dim model and ml_service_client code

Now that new ml agent is enabled by default, we can remove the old model
and ml_service_client code of smart dim.

Also change the unit test accordingly.

Bug: 1067048, 1136331
Test: Unit test passed & tested on DUT
Change-Id: Ife97ecd54d0dec0ddcd6c816517c4c71629ce0eb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2462989Reviewed-by: Andrew Moylan <amoylan@chromium.org>
Reviewed-by: Xinglong Luan <alanlxl@chromium.org>
Commit-Queue: Xinglong Luan <alanlxl@chromium.org>
Cr-Commit-Position: refs/heads/master@{#816439}

chrome/browser/chromeos/BUILD.gn

@@ -3612,7 +3612,6 @@ source_set("unit_tests") {
     "power/ml/recent_events_counter_unittest.cc",
     "power/ml/smart_dim/ml_agent_unittest.cc",
     "power/ml/smart_dim/ml_agent_util_unittest.cc",
-    "power/ml/smart_dim/model_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",

chrome/browser/chromeos/power/ml/smart_dim/BUILD.gn

@@ -6,8 +6,6 @@ source_set("smart_dim") {
   public = [
     "metrics.h",
     "ml_agent.h",
-    "model.h",
-    "model_impl.h",
   ]
 
   sources = [
@@ -20,11 +18,6 @@ source_set("smart_dim") {
     "ml_agent.h",
     "ml_agent_util.cc",
     "ml_agent_util.h",
-    "ml_service_client.cc",
-    "ml_service_client.h",
-    "model.h",
-    "model_impl.cc",
-    "model_impl.h",
     "smart_dim_worker.cc",
     "smart_dim_worker.h",
   ]

chrome/browser/chromeos/power/ml/smart_dim/model.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_SMART_DIM_MODEL_H_
-#define CHROME_BROWSER_CHROMEOS_POWER_ML_SMART_DIM_MODEL_H_
-
-#include "base/callback.h"
-#include "chrome/browser/chromeos/power/ml/user_activity_event.pb.h"
-
-namespace chromeos {
-namespace power {
-namespace ml {
-
-// Interface to indicate whether an upcoming screen dim should go ahead based on
-// whether user will remain inactive if screen is dimmed now.
-class SmartDimModel {
- public:
-  using DimDecisionCallback =
-      base::OnceCallback<void(UserActivityEvent::ModelPrediction)>;
-  virtual ~SmartDimModel() = default;
-
-  // Post a request to determine whether an upcoming dim should go ahead based
-  // on input |features|. When a decision is arrived at, run the callback
-  // specified by |dim_callback|. If this method is called again before it
-  // calls the previous callback, the previous callback will be canceled.
-  virtual void RequestDimDecision(const UserActivityEvent::Features& features,
-                                  DimDecisionCallback dim_callback) = 0;
-
-  // Cancel a previous dim decision request, if one is pending. If no dim
-  // decision request is pending, this function has no effect.
-  virtual void CancelPreviousRequest() = 0;
-};
-
-}  // namespace ml
-}  // namespace power
-}  // namespace chromeos
-
-#endif  // CHROME_BROWSER_CHROMEOS_POWER_ML_SMART_DIM_MODEL_H_

chrome/browser/chromeos/power/ml/smart_dim/model_impl.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_SMART_DIM_MODEL_IMPL_H_
-#define CHROME_BROWSER_CHROMEOS_POWER_ML_SMART_DIM_MODEL_IMPL_H_
-
-#include <memory>
-
-#include "base/cancelable_callback.h"
-#include "base/macros.h"
-#include "base/sequenced_task_runner.h"
-#include "base/time/time.h"
-#include "chrome/browser/chromeos/power/ml/smart_dim/metrics.h"
-#include "chrome/browser/chromeos/power/ml/smart_dim/ml_service_client.h"
-#include "chrome/browser/chromeos/power/ml/smart_dim/model.h"
-
-namespace assist_ranker {
-class ExamplePreprocessorConfig;
-}  // namespace assist_ranker
-
-namespace chromeos {
-namespace power {
-namespace ml {
-
-// Real implementation of SmartDimModel that predicts whether an upcoming screen
-// dim should go ahead based on user activity/inactivity following dim.
-class SmartDimModelImpl : public SmartDimModel {
- public:
-  SmartDimModelImpl();
-  ~SmartDimModelImpl() override;
-
-  // chromeos::power::ml::SmartDimModel overrides:
-  void RequestDimDecision(const UserActivityEvent::Features& features,
-                          DimDecisionCallback dim_callback) override;
-  void CancelPreviousRequest() override;
-
-  // Override MlServiceClient in a unit test environment where there is no real
-  // ML Service daemon to connect to.
-  void SetMlServiceClientForTesting(std::unique_ptr<MlServiceClient> client);
-
- private:
-  // Loads the preprocessor config if not already loaded. Also initializes the
-  // MlServiceClient object.
-  void LazyInitialize();
-
-  // Pre-processes the input features into a vector, placed in
-  // |*vectorized_features|, which is consumable by the ML model.
-  //
-  // Returns SmartDimModelResult::kSuccess on success, and the appropriate
-  // error on failure.
-  SmartDimModelResult PreprocessInput(
-      const UserActivityEvent::Features& features,
-      std::vector<float>* vectorized_features);
-
-  // Takes an |inactivity_score| returned from the ML model and, using that,
-  // returns a ModelPrediction.
-  UserActivityEvent::ModelPrediction CreatePredictionFromInactivityScore(
-      float inactivity_score);
-
-  // Calls the ML service Mojo API to perform an Smart Dim inference call,
-  // given |input_features|. The |callback| is supplied to the Mojo API,
-  // which in turn will call it to provide the result (a ModelPrediction), once
-  // the inference is complete.
-  void ShouldDim(const UserActivityEvent::Features& input_features,
-                 DimDecisionCallback callback);
-
-  std::unique_ptr<assist_ranker::ExamplePreprocessorConfig>
-      preprocessor_config_;
-
-  // Cancelable wrapper for the DimDecisionCallback passed by the client to
-  // RequestDimDecision().
-  base::CancelableOnceCallback<void(UserActivityEvent::ModelPrediction)>
-      cancelable_callback_;
-
-  // Pointer to the object that handles the ML service calls.
-  std::unique_ptr<MlServiceClient> ml_service_client_;
-
-  SEQUENCE_CHECKER(sequence_checker_);
-
-  DISALLOW_COPY_AND_ASSIGN(SmartDimModelImpl);
-};
-
-}  // namespace ml
-}  // namespace power
-}  // namespace chromeos
-
-#endif  // CHROME_BROWSER_CHROMEOS_POWER_ML_SMART_DIM_MODEL_IMPL_H_

chrome/browser/chromeos/power/ml/smart_dim/model_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/smart_dim/model_impl.h"
-
-#include <memory>
-
-#include "base/bind.h"
-#include "base/macros.h"
-#include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/test/scoped_feature_list.h"
-#include "base/test/task_environment.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/time/time.h"
-#include "chrome/browser/chromeos/power/ml/user_activity_event.pb.h"
-#include "chromeos/constants/chromeos_features.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/base/page_transition_types.h"
-
-namespace chromeos {
-namespace power {
-namespace ml {
-
-namespace {
-
-// Arbitrary inactivity score for the fake ML Service client to return:
-constexpr float kTestInactivityScore = -3.7;
-// Quantized into the range [0, 100] via sigmoid transform:
-constexpr int kQuantizedTestInactivityScore = 2;
-
-// Arbitrary dim thresholds lower/higher than kTestInactivityScore, implying
-// no/yes dim decisions respectively.
-constexpr double kLowDimThreshold = -10.0;
-constexpr double kHighDimThreshold = -0.1;
-// Same values quantized into the range [0, 100] via sigmoid transform:
-constexpr int kQuantizedLowDimThreshold = 0;
-constexpr int kQuantizedHighDimThreshold = 47;
-
-UserActivityEvent::Features DefaultFeatures() {
-  UserActivityEvent::Features features;
-  // Bucketize to 95.
-  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);
-  // Bucketize to 200.
-  features.set_key_events_in_last_hour(290);
-  features.set_last_activity_day(UserActivityEvent::Features::THU);
-  // Bucketize to 7.
-  features.set_last_activity_time_sec(25920);
-  // Bucketize to 7.
-  features.set_last_user_activity_time_sec(25920);
-  // Bucketize to 2000.
-  features.set_mouse_events_in_last_hour(2600);
-  features.set_on_battery(false);
-  features.set_previous_negative_actions_count(3);
-  features.set_previous_positive_actions_count(0);
-  features.set_recent_time_active_sec(190);
-  features.set_video_playing_time_sec(0);
-  features.set_on_to_dim_sec(30);
-  features.set_dim_to_screen_off_sec(10);
-  features.set_time_since_last_key_sec(30);
-  features.set_time_since_last_mouse_sec(688);
-  // Bucketize to 900.
-  features.set_time_since_video_ended_sec(1100);
-  features.set_has_form_entry(false);
-  features.set_source_id(123);  // not used.
-  features.set_engagement_score(40);
-  features.set_tab_domain("//mail.google.com");
-  return features;
-}
-
-// Class to hold scoped local modifications to Smart-dim related feature flags.
-class SmartDimFeatureFlags {
- public:
-  SmartDimFeatureFlags() = default;
-
-  void Initialize(const double dim_threshold) {
-    const std::map<std::string, std::string> params = {
-        {"dim_threshold", base::NumberToString(dim_threshold)}};
-    smart_dim_feature_override_.InitAndEnableFeatureWithParameters(
-        features::kUserActivityPrediction, params);
-  }
-
- private:
-  base::test::ScopedFeatureList smart_dim_feature_override_;
-
-  DISALLOW_COPY_AND_ASSIGN(SmartDimFeatureFlags);
-};
-
-class FakeMlServiceClient : public MlServiceClient {
- public:
-  FakeMlServiceClient() = default;
-  ~FakeMlServiceClient() override {}
-
-  // MlServiceClient:
-  void DoInference(
-      const std::vector<float>& features,
-      base::RepeatingCallback<UserActivityEvent::ModelPrediction(float)>
-          get_prediction_callback,
-      SmartDimModel::DimDecisionCallback decision_callback) override {
-    const float inactivity_score = kTestInactivityScore;
-
-    UserActivityEvent::ModelPrediction model_prediction =
-        get_prediction_callback.Run(inactivity_score);
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::BindOnce(std::move(decision_callback), model_prediction));
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FakeMlServiceClient);
-};
-
-}  // namespace
-
-class SmartDimModelImplTest : public testing::Test {
- public:
-  SmartDimModelImplTest()
-      : task_environment_(
-            base::test::TaskEnvironment::MainThreadType::IO,
-            base::test::TaskEnvironment::ThreadPoolExecutionMode::QUEUED) {}
-
-  ~SmartDimModelImplTest() override = default;
-
- protected:
-  // Sets a fake MlServiceClient into |impl|.
-  void InjectFakeMlServiceClient(SmartDimModelImpl* const impl) {
-    impl->SetMlServiceClientForTesting(std::make_unique<FakeMlServiceClient>());
-  }
-
-  base::test::TaskEnvironment task_environment_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SmartDimModelImplTest);
-};
-
-// With a high dim threshold, NO_DIM decision is expected.
-TEST_F(SmartDimModelImplTest, ShouldNotDim) {
-  SmartDimFeatureFlags flags;
-  flags.Initialize(kHighDimThreshold);
-
-  SmartDimModelImpl smart_dim_model;
-  InjectFakeMlServiceClient(&smart_dim_model);
-
-  bool callback_done = false;
-  smart_dim_model.RequestDimDecision(
-      DefaultFeatures(), base::BindOnce(
-                             [](bool* callback_done,
-                                UserActivityEvent::ModelPrediction prediction) {
-                               EXPECT_EQ(
-                                   UserActivityEvent::ModelPrediction::NO_DIM,
-                                   prediction.response());
-                               EXPECT_EQ(kQuantizedHighDimThreshold,
-                                         prediction.decision_threshold());
-                               EXPECT_EQ(kQuantizedTestInactivityScore,
-                                         prediction.inactivity_score());
-                               *callback_done = true;
-                             },
-                             &callback_done));
-  task_environment_.RunUntilIdle();
-  EXPECT_TRUE(callback_done);
-}
-
-// With a low dim threshold, DIM decision is expected.
-TEST_F(SmartDimModelImplTest, ShouldDim) {
-  SmartDimFeatureFlags flags;
-  flags.Initialize(kLowDimThreshold);
-
-  SmartDimModelImpl smart_dim_model;
-  InjectFakeMlServiceClient(&smart_dim_model);
-
-  bool callback_done = false;
-  smart_dim_model.RequestDimDecision(
-      DefaultFeatures(), base::BindOnce(
-                             [](bool* callback_done,
-                                UserActivityEvent::ModelPrediction prediction) {
-                               EXPECT_EQ(
-                                   UserActivityEvent::ModelPrediction::DIM,
-                                   prediction.response());
-                               EXPECT_EQ(kQuantizedLowDimThreshold,
-                                         prediction.decision_threshold());
-                               EXPECT_EQ(kQuantizedTestInactivityScore,
-                                         prediction.inactivity_score());
-                               *callback_done = true;
-                             },
-                             &callback_done));
-  task_environment_.RunUntilIdle();
-  EXPECT_TRUE(callback_done);
-}
-
-// Check that CancelableCallback ensures a callback doesn't execute twice, in
-// case two RequestDimDecision() calls were made before any callback ran.
-TEST_F(SmartDimModelImplTest, CheckCancelableCallback) {
-  SmartDimFeatureFlags flags;
-  flags.Initialize(kLowDimThreshold);
-
-  SmartDimModelImpl smart_dim_model;
-  InjectFakeMlServiceClient(&smart_dim_model);
-
-  bool callback_done = false;
-  int num_callbacks_run = 0;
-  for (int i = 0; i < 2; i++) {
-    smart_dim_model.RequestDimDecision(
-        DefaultFeatures(),
-        base::BindOnce(
-            [](bool* callback_done, int* num_callbacks_run,
-               UserActivityEvent::ModelPrediction prediction) {
-              EXPECT_EQ(UserActivityEvent::ModelPrediction::DIM,
-                        prediction.response());
-              EXPECT_EQ(kQuantizedLowDimThreshold,
-                        prediction.decision_threshold());
-              EXPECT_EQ(kQuantizedTestInactivityScore,
-                        prediction.inactivity_score());
-              *callback_done = true;
-              (*num_callbacks_run)++;
-            },
-            &callback_done, &num_callbacks_run));
-  }
-  task_environment_.RunUntilIdle();
-  EXPECT_TRUE(callback_done);
-  EXPECT_EQ(1, num_callbacks_run);
-}
-
-// Check that CancelPreviousRequest() can successfully prevent a previous
-// requested dim decision request from running.
-TEST_F(SmartDimModelImplTest, CheckCanceledRequest) {
-  SmartDimFeatureFlags flags;
-  flags.Initialize(kLowDimThreshold);
-
-  SmartDimModelImpl smart_dim_model;
-  InjectFakeMlServiceClient(&smart_dim_model);
-
-  bool callback_done = false;
-  smart_dim_model.RequestDimDecision(
-      DefaultFeatures(), base::BindOnce(
-                             [](bool* callback_done,
-                                UserActivityEvent::ModelPrediction prediction) {
-                               *callback_done = true;
-                             },
-                             &callback_done));
-  smart_dim_model.CancelPreviousRequest();
-  task_environment_.RunUntilIdle();
-  EXPECT_FALSE(callback_done);
-}
-
-}  // namespace ml
-}  // namespace power
-}  // namespace chromeos

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

@@ -51,7 +51,7 @@ UserActivityController::UserActivityController() {
       &user_activity_ukm_logger_, detector, power_manager_client,
       session_manager,
       video_observer_user_logger.InitWithNewPipeAndPassReceiver(),
-      chromeos::ChromeUserManager::Get(), &smart_dim_model_);
+      chromeos::ChromeUserManager::Get());
   aura::Env::GetInstance()
       ->context_factory()
       ->GetHostFrameSinkManager()

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

@@ -9,7 +9,6 @@
 
 #include "base/callback.h"
 #include "chrome/browser/chromeos/power/ml/idle_event_notifier.h"
-#include "chrome/browser/chromeos/power/ml/smart_dim/model_impl.h"
 #include "chrome/browser/chromeos/power/ml/user_activity_manager.h"
 #include "chrome/browser/chromeos/power/ml/user_activity_ukm_logger_impl.h"
 
@@ -33,7 +32,6 @@ class UserActivityController {
   std::unique_ptr<IdleEventNotifier> idle_event_notifier_;
   UserActivityUkmLoggerImpl user_activity_ukm_logger_;
   std::unique_ptr<UserActivityManager> user_activity_manager_;
-  SmartDimModelImpl smart_dim_model_;
 
   DISALLOW_COPY_AND_ASSIGN(UserActivityController);
 };

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

@@ -105,10 +105,8 @@ UserActivityManager::UserActivityManager(
     chromeos::PowerManagerClient* power_manager_client,
     session_manager::SessionManager* session_manager,
     mojo::PendingReceiver<viz::mojom::VideoDetectorObserver> receiver,
-    const chromeos::ChromeUserManager* user_manager,
-    SmartDimModel* smart_dim_model)
+    const chromeos::ChromeUserManager* user_manager)
     : ukm_logger_(ukm_logger),
-      smart_dim_model_(smart_dim_model),
       user_activity_observer_(this),
       power_manager_client_observer_(this),
       session_manager_observer_(this),
@@ -263,19 +261,14 @@ void UserActivityManager::UpdateAndGetSmartDimDecision(
         profile->GetPrefs()->GetBoolean(ash::prefs::kPowerSmartDimEnabled);
   }
   if (smart_dim_enabled &&
-      base::FeatureList::IsEnabled(features::kUserActivityPrediction) &&
-      SmartDimModelReady()) {
+      base::FeatureList::IsEnabled(features::kUserActivityPrediction)) {
     waiting_for_model_decision_ = true;
     time_dim_decision_requested_ = base::TimeTicks::Now();
     auto request_callback =
         base::BindOnce(&UserActivityManager::HandleSmartDimDecision,
                        weak_ptr_factory_.GetWeakPtr(), std::move(callback));
-    if (base::FeatureList::IsEnabled(features::kSmartDimNewMlAgent))
-      SmartDimMlAgent::GetInstance()->RequestDimDecision(
-          features_, std::move(request_callback));
-    else
-      smart_dim_model_->RequestDimDecision(features_,
-                                           std::move(request_callback));
+    SmartDimMlAgent::GetInstance()->RequestDimDecision(
+        features_, std::move(request_callback));
   }
   waiting_for_final_action_ = true;
 }
@@ -560,8 +553,7 @@ void UserActivityManager::PopulatePreviousEventData(
     const base::TimeDelta& now) {
   PreviousEventLoggingResult result = PreviousEventLoggingResult::kSuccess;
   if (!model_prediction_) {
-    result = base::FeatureList::IsEnabled(features::kUserActivityPrediction) &&
-                     SmartDimModelReady()
+    result = base::FeatureList::IsEnabled(features::kUserActivityPrediction)
                  ? PreviousEventLoggingResult::kErrorModelPredictionMissing
                  : PreviousEventLoggingResult::kErrorModelDisabled;
     LogPowerMLPreviousEventLoggingResult(result);
@@ -605,10 +597,7 @@ void UserActivityManager::ResetAfterLogging() {
 
 void UserActivityManager::CancelDimDecisionRequest() {
   LOG(WARNING) << "Cancelling pending Smart Dim decision request.";
-  if (base::FeatureList::IsEnabled(features::kSmartDimNewMlAgent))
-    SmartDimMlAgent::GetInstance()->CancelPreviousRequest();
-  else
-    smart_dim_model_->CancelPreviousRequest();
+  SmartDimMlAgent::GetInstance()->CancelPreviousRequest();
 
   waiting_for_model_decision_ = false;
   const base::TimeDelta wait_time =
@@ -617,13 +606,6 @@ void UserActivityManager::CancelDimDecisionRequest() {
   time_dim_decision_requested_ = base::TimeTicks();
 }
 
-bool UserActivityManager::SmartDimModelReady() {
-  // We assume that BuiltinWorker of SmartDimMlAgent can always load model and
-  // preprocessor config from rootfs, therefore SmartDimMlAgent is always ready.
-  return base::FeatureList::IsEnabled(features::kSmartDimNewMlAgent) ||
-         smart_dim_model_;
-}
-
 }  // namespace ml
 }  // namespace power
 }  // namespace chromeos

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

@@ -13,7 +13,6 @@
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/power/ml/boot_clock.h"
 #include "chrome/browser/chromeos/power/ml/idle_event_notifier.h"
-#include "chrome/browser/chromeos/power/ml/smart_dim/model.h"
 #include "chrome/browser/chromeos/power/ml/user_activity_event.pb.h"
 #include "chrome/browser/chromeos/power/ml/user_activity_ukm_logger.h"
 #include "chrome/browser/resource_coordinator/tab_metrics_event.pb.h"
@@ -85,8 +84,7 @@ class UserActivityManager : public ui::UserActivityObserver,
       chromeos::PowerManagerClient* power_manager_client,
       session_manager::SessionManager* session_manager,
       mojo::PendingReceiver<viz::mojom::VideoDetectorObserver> receiver,
-      const chromeos::ChromeUserManager* user_manager,
-      SmartDimModel* smart_dim_model);
+      const chromeos::ChromeUserManager* user_manager);
   ~UserActivityManager() override;
 
   // ui::UserActivityObserver overrides.
@@ -155,12 +153,9 @@ class UserActivityManager : public ui::UserActivityObserver,
 
   void ResetAfterLogging();
 
-  // Cancel any pending request to |smart_dim_model_| to get a dim decision.
+  // Cancel any pending request to `SmartDimMlAgent` to get a dim decision.
   void CancelDimDecisionRequest();
 
-  // If old smart dim model or new SmartDimMlAgent is ready, based on Finch.
-  bool SmartDimModelReady();
-
   // Time when an idle event is received and we start logging. Null if an idle
   // event hasn't been observed.
   base::Optional<base::TimeDelta> idle_event_start_since_boot_;
@@ -190,8 +185,6 @@ class UserActivityManager : public ui::UserActivityObserver,
 
   UserActivityUkmLogger* const ukm_logger_;
 
-  SmartDimModel* const smart_dim_model_;
-
   ScopedObserver<ui::UserActivityDetector, ui::UserActivityObserver>
       user_activity_observer_;
   ScopedObserver<chromeos::PowerManagerClient,
@@ -235,7 +228,7 @@ class UserActivityManager : public ui::UserActivityObserver,
   // set to true after we've received an idle event, but haven't received final
   // action to log the event.
   bool waiting_for_final_action_ = false;
-  // Whether we are waiting for a decision from the |smart_dim_model_|
+  // Whether we are waiting for a decision from the `SmartDimMlAgent`
   // regarding whether to proceed with a dim or not. It is only set
   // to true in OnIdleEventObserved() when we request a dim decision.
   bool waiting_for_model_decision_ = false;