CreateInstance method for Manager for Screen Brightness project.

Bug: 820883
Change-Id: Ic696e1cb77106dbb7df5ccb4a9aa276eb8e5a1d7
Reviewed-on: https://chromium-review.googlesource.com/982774
Commit-Queue: Paul Dyson <pdyson@chromium.org>
Reviewed-by: Jia Meng <jiameng@chromium.org>
Reviewed-by: Michael Giuffrida <michaelpg@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
Reviewed-by: Michael Martis <martis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#548326}

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

@@ -10,15 +10,24 @@
 #include "base/process/launch.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/time/clock.h"
+#include "base/time/default_clock.h"
+#include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/accessibility/magnification_manager.h"
+#include "chrome/browser/chromeos/ash_config.h"
 #include "chrome/browser/chromeos/power/ml/adaptive_screen_brightness_ukm_logger.h"
+#include "chrome/browser/chromeos/power/ml/adaptive_screen_brightness_ukm_logger_impl.h"
 #include "chrome/browser/chromeos/power/ml/real_boot_clock.h"
 #include "chrome/browser/chromeos/power/ml/recent_events_counter.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager/backlight.pb.h"
+#include "chromeos/system/devicetype.h"
 #include "components/prefs/pref_service.h"
+#include "components/viz/host/host_frame_sink_manager.h"
+#include "services/viz/public/interfaces/compositing/video_detector_observer.mojom.h"
+#include "ui/aura/env.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 
 namespace chromeos {
@@ -42,7 +51,7 @@ constexpr base::TimeDelta kLoggingInterval = base::TimeDelta::FromMinutes(10);
 constexpr base::TimeDelta AdaptiveScreenBrightnessManager::kInactivityDuration;
 
 AdaptiveScreenBrightnessManager::AdaptiveScreenBrightnessManager(
-    AdaptiveScreenBrightnessUkmLogger* ukm_logger,
+    std::unique_ptr<AdaptiveScreenBrightnessUkmLogger> ukm_logger,
     ui::UserActivityDetector* detector,
     chromeos::PowerManagerClient* power_manager_client,
     AccessibilityManager* accessibility_manager,
@@ -54,7 +63,7 @@ AdaptiveScreenBrightnessManager::AdaptiveScreenBrightnessManager(
     : clock_(clock),
       boot_clock_(std::move(boot_clock)),
       periodic_timer_(std::move(periodic_timer)),
-      ukm_logger_(ukm_logger),
+      ukm_logger_(std::move(ukm_logger)),
       user_activity_observer_(this),
       power_manager_client_observer_(this),
       accessibility_manager_(accessibility_manager),
@@ -93,6 +102,44 @@ AdaptiveScreenBrightnessManager::AdaptiveScreenBrightnessManager(
 
 AdaptiveScreenBrightnessManager::~AdaptiveScreenBrightnessManager() = default;
 
+std::unique_ptr<AdaptiveScreenBrightnessManager>
+AdaptiveScreenBrightnessManager::CreateInstance() {
+  // TODO(jiameng): video detector below doesn't work with MASH. Temporary
+  // solution is to disable logging if we're under MASH env.
+  if (chromeos::GetDeviceType() != chromeos::DeviceType::kChromebook ||
+      chromeos::GetAshConfig() == ash::Config::MASH) {
+    return nullptr;
+  }
+
+  chromeos::PowerManagerClient* const power_manager_client =
+      chromeos::DBusThreadManager::Get()->GetPowerManagerClient();
+  DCHECK(power_manager_client);
+  ui::UserActivityDetector* const detector = ui::UserActivityDetector::Get();
+  DCHECK(detector);
+  AccessibilityManager* const accessibility_manager =
+      AccessibilityManager::Get();
+  DCHECK(accessibility_manager);
+  MagnificationManager* const magnification_manager =
+      MagnificationManager::Get();
+  DCHECK(magnification_manager);
+  viz::mojom::VideoDetectorObserverPtr video_observer_screen_brightness_logger;
+
+  std::unique_ptr<AdaptiveScreenBrightnessManager> screen_brightness_manager =
+      std::make_unique<AdaptiveScreenBrightnessManager>(
+          std::make_unique<AdaptiveScreenBrightnessUkmLoggerImpl>(), detector,
+          power_manager_client, accessibility_manager, magnification_manager,
+          mojo::MakeRequest(&video_observer_screen_brightness_logger),
+          std::make_unique<base::RepeatingTimer>(),
+          base::DefaultClock::GetInstance(), std::make_unique<RealBootClock>());
+  aura::Env::GetInstance()
+      ->context_factory_private()
+      ->GetHostFrameSinkManager()
+      ->AddVideoDetectorObserver(
+          std::move(video_observer_screen_brightness_logger));
+
+  return screen_brightness_manager;
+}
+
 void AdaptiveScreenBrightnessManager::OnUserActivity(
     const ui::Event* const event) {
   if (!event)

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

@@ -52,7 +52,7 @@ class AdaptiveScreenBrightnessManager
       base::TimeDelta::FromSeconds(20);
 
   AdaptiveScreenBrightnessManager(
-      AdaptiveScreenBrightnessUkmLogger* ukm_logger,
+      std::unique_ptr<AdaptiveScreenBrightnessUkmLogger> ukm_logger,
       ui::UserActivityDetector* detector,
       chromeos::PowerManagerClient* power_manager_client,
       AccessibilityManager* accessibility_manager,
@@ -64,6 +64,9 @@ class AdaptiveScreenBrightnessManager
 
   ~AdaptiveScreenBrightnessManager() override;
 
+  // Returns a new instance of AdaptiveScreenBrightnessManager.
+  static std::unique_ptr<AdaptiveScreenBrightnessManager> CreateInstance();
+
   // ui::UserActivityObserver overrides:
   void OnUserActivity(const ui::Event* event) override;
 
@@ -108,7 +111,7 @@ class AdaptiveScreenBrightnessManager
   // Timer to trigger periodically for logging data.
   const std::unique_ptr<base::RepeatingTimer> periodic_timer_;
 
-  AdaptiveScreenBrightnessUkmLogger* const ukm_logger_;
+  const std::unique_ptr<AdaptiveScreenBrightnessUkmLogger> ukm_logger_;
 
   ScopedObserver<ui::UserActivityDetector, ui::UserActivityObserver>
       user_activity_observer_;

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

@@ -62,16 +62,19 @@ class AdaptiveScreenBrightnessManagerTest : public testing::Test {
       : task_runner_(base::MakeRefCounted<base::TestMockTimeTaskRunner>(
             base::TestMockTimeTaskRunner::Type::kBoundToThread)),
         scoped_context_(task_runner_.get()) {
+    auto logger = std::make_unique<TestingAdaptiveScreenBrightnessUkmLogger>();
+    ukm_logger_ = logger.get();
+
     fake_power_manager_client_.Init(nullptr);
     viz::mojom::VideoDetectorObserverPtr observer;
-    std::unique_ptr<base::RepeatingTimer> periodic_timer =
-        std::make_unique<base::RepeatingTimer>();
+    auto periodic_timer = std::make_unique<base::RepeatingTimer>();
     periodic_timer->SetTaskRunner(task_runner_);
     screen_brightness_manager_ =
         std::make_unique<AdaptiveScreenBrightnessManager>(
-            &ukm_logger_, &user_activity_detector_, &fake_power_manager_client_,
-            nullptr, nullptr, mojo::MakeRequest(&observer),
-            std::move(periodic_timer), task_runner_->GetMockClock(),
+            std::move(logger), &user_activity_detector_,
+            &fake_power_manager_client_, nullptr, nullptr,
+            mojo::MakeRequest(&observer), std::move(periodic_timer),
+            task_runner_->GetMockClock(),
             std::make_unique<FakeBootClock>(task_runner_,
                                             base::TimeDelta::FromSeconds(10)));
   }
@@ -79,6 +82,8 @@ class AdaptiveScreenBrightnessManagerTest : public testing::Test {
   ~AdaptiveScreenBrightnessManagerTest() override = default;
 
  protected:
+  TestingAdaptiveScreenBrightnessUkmLogger* ukm_logger() { return ukm_logger_; }
+
   void ReportUserActivity(const ui::Event* const event) {
     screen_brightness_manager_->OnUserActivity(event);
   }
@@ -127,7 +132,6 @@ class AdaptiveScreenBrightnessManagerTest : public testing::Test {
     task_runner_->FastForwardBy(base::TimeDelta::FromSeconds(seconds));
   }
 
-  TestingAdaptiveScreenBrightnessUkmLogger ukm_logger_;
   const gfx::Point kEventLocation = gfx::Point(90, 90);
   const ui::MouseEvent kMouseEvent = ui::MouseEvent(ui::ET_MOUSE_MOVED,
                                                     kEventLocation,
@@ -144,6 +148,7 @@ class AdaptiveScreenBrightnessManagerTest : public testing::Test {
   ui::UserActivityDetector user_activity_detector_;
   chromeos::FakePowerManagerClient fake_power_manager_client_;
   std::unique_ptr<AdaptiveScreenBrightnessManager> screen_brightness_manager_;
+  TestingAdaptiveScreenBrightnessUkmLogger* ukm_logger_;
 
   DISALLOW_COPY_AND_ASSIGN(AdaptiveScreenBrightnessManagerTest);
 };
@@ -158,7 +163,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, PeriodicLogging) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
 
   const ScreenBrightnessEvent::Features& features =
@@ -184,7 +189,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, BrightnessChange) {
       20.0f, power_manager::BacklightBrightnessChange_Cause_USER_REQUEST);
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(3U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Event& event =
       screen_brightness_events[0].event();
@@ -208,7 +213,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, NoUserEvents) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   // This counts logging events, not user events.
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
@@ -226,7 +231,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, NullUserActivity) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -243,7 +248,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, OneUserEvent) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -264,7 +269,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, TwoUserEventsSameActivity) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -285,7 +290,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, TwoUserEventsDifferentActivities) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -319,7 +324,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest,
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -340,7 +345,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, VideoStartStop) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(2U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -397,7 +402,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, VideoStartStopWithUserEvents) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(3U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();
@@ -469,7 +474,7 @@ TEST_F(AdaptiveScreenBrightnessManagerTest, UserEventCounts) {
   FireTimer();
 
   const std::vector<ScreenBrightnessEvent>& screen_brightness_events =
-      ukm_logger_.screen_brightness_events();
+      ukm_logger()->screen_brightness_events();
   ASSERT_EQ(1U, screen_brightness_events.size());
   const ScreenBrightnessEvent::Features& features =
       screen_brightness_events[0].features();