Introduce DisplayConfigurationController

ash/display/display_configuration_controller.cc

Index: ash/display/display_configuration_controller.cc
diff --git a/ash/display/display_configuration_controller.cc b/ash/display/display_configuration_controller.cc
new file mode 100644
index 0000000000000000000000000000000000000000..85ae04b119fd4757825451920ea801793719351e
--- /dev/null
+++ b/ash/display/display_configuration_controller.cc
@@ -0,0 +1,169 @@
+// 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 "ash/display/display_configuration_controller.h"
+
+#include "ash/display/display_animator.h"
+#include "ash/display/display_layout.h"
+#include "ash/display/display_manager.h"
+#include "ash/rotator/screen_rotation_animator.h"
+#include "ash/screen_util.h"
+#include "base/sys_info.h"
+#include "base/time/time.h"
+#include "ui/display/chromeos/display_configurator.h"
+
+namespace {
+
+// Specifies how long the display change should have been disabled
+// after each display change operations.
+// |kCycleDisplayThrottleTimeoutMs| is set to be longer to avoid
+// changing the settings while the system is still configurating
+// displays. It will be overriden by |kAfterDisplayChangeThrottleTimeoutMs|
+// when the display change happens, so the actual timeout is much shorter.
+const int64_t kAfterDisplayChangeThrottleTimeoutMs = 500;
+const int64_t kCycleDisplayThrottleTimeoutMs = 4000;
+const int64_t kSetPrimaryDisplayThrottleTimeoutMs = 500;
+
+}  // namespace
+
+namespace ash {
+
+class DisplayConfigurationController::DisplayChangeLimiter {
+ public:
+  DisplayChangeLimiter() : throttle_timeout_(base::Time::Now()) {}
+
+  void SetThrottleTimeout(int64_t throttle_ms) {
+    throttle_timeout_ =
+        base::Time::Now() + base::TimeDelta::FromMilliseconds(throttle_ms);
+  }
+
+  bool IsThrottled() const { return base::Time::Now() < throttle_timeout_; }
+
+ private:
+  base::Time throttle_timeout_;
+
+  DISALLOW_COPY_AND_ASSIGN(DisplayChangeLimiter);
+};
+
+DisplayConfigurationController::DisplayConfigurationController(
+    ui::DisplayConfigurator* display_configurator,
+    DisplayManager* display_manager,
+    WindowTreeHostManager* window_tree_host_manager)
+    : display_configurator_(display_configurator),
+      display_manager_(display_manager),
+      window_tree_host_manager_(window_tree_host_manager),
+      display_animator_(new DisplayAnimator),
+      weak_ptr_factory_(this) {
+  if (base::SysInfo::IsRunningOnChromeOS())
+    limiter_.reset(new DisplayChangeLimiter);
+  display_configurator_->AddObserver(display_animator_.get());
+  window_tree_host_manager_->AddObserver(this);
+}
+
+DisplayConfigurationController::~DisplayConfigurationController() {
+  window_tree_host_manager_->RemoveObserver(this);
+  display_configurator_->RemoveObserver(display_animator_.get());

[oshima, 2016/01/19 18:49:16]

can we move this (add/remove) code to animator?

[stevenjb, 2016/01/19 20:32:04]

I'm not sure I understand. This class now owns the animator. I could change the
animator to require a Delegate to be passed in the constructor instead of
supporting observers if that is what you are suggesting?

[oshima, 2016/01/19 20:59:30]

DisplayConfigurator is used only for animator, so you create an Animator (and
add/remove observer in ctor/dtor) and it instead. The animator already depends
on DisplayCOnfigurator, so we can minimize the dependency that way.

[stevenjb, 2016/01/20 01:25:36]

Ah, I think I understand what you mean. I did a bit of re-factoring and I think
the result is a bit simpler, with less #if OS_CHROMEOS in the code.

+}
+
+void DisplayConfigurationController::SetDisplayLayout(
+    int64_t display_id,
+    const DisplayLayout& layout,
+    bool user_action) {
+  if (user_action && display_animator_) {
+    display_animator_->StartFadeOutAnimation(
+        base::Bind(&DisplayConfigurationController::SetLayoutImpl,
+                   weak_ptr_factory_.GetWeakPtr(), display_id, layout));
+  } else {
+    SetLayoutImpl(display_id, layout);
+  }
+}
+
+void DisplayConfigurationController::SetMirrorMode(bool mirror,
+                                                   bool user_action) {
+  if (display_manager_->GetNumDisplays() <= 1 ||
+      display_manager_->IsInMirrorMode() == mirror || IsLimited()) {
+    return;
+  }
+  if (user_action && display_animator_) {
+    display_animator_->StartFadeOutAnimation(
+        base::Bind(&DisplayConfigurationController::SetMirrorModeImpl,
+                   weak_ptr_factory_.GetWeakPtr(), mirror));
+  } else {
+    SetMirrorModeImpl(mirror);
+  }
+}
+
+void DisplayConfigurationController::SetDisplayRotation(
+    int64_t display_id,
+    gfx::Display::Rotation rotation,
+    gfx::Display::RotationSource source,
+    bool user_action) {
+  ash::ScreenRotationAnimator screen_rotation_animator(display_id);
+  if (user_action && screen_rotation_animator.CanAnimate())
+    screen_rotation_animator.Rotate(rotation, source);
+  else
+    display_manager_->SetDisplayRotation(display_id, rotation, source);
+}
+
+void DisplayConfigurationController::SetPrimaryDisplayId(int64_t display_id,
+                                                         bool user_action) {
+  if (display_manager_->GetNumDisplays() <= 1 || IsLimited())
+    return;
+
+  if (user_action && display_animator_) {
+    display_animator_->StartFadeOutAnimation(
+        base::Bind(&DisplayConfigurationController::SetPrimaryDisplayIdImpl,
+                   weak_ptr_factory_.GetWeakPtr(), display_id));
+  } else {
+    SetPrimaryDisplayIdImpl(display_id);
+  }
+}
+
+void DisplayConfigurationController::OnDisplayConfigurationChanged() {
+  if (limiter_)
+    limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
+}
+
+// Protected
+
+void DisplayConfigurationController::ResetAnimatorForTest() {
+  if (!display_animator_)
+    return;
+  display_configurator_->RemoveObserver(display_animator_.get());
+  display_animator_.reset();
+}
+
+// Private
+
+bool DisplayConfigurationController::IsLimited() {
+  return limiter_ && limiter_->IsThrottled();
+}
+
+void DisplayConfigurationController::SetLayoutImpl(
+    int64_t display_id,
+    const DisplayLayout& layout) {
+  // TODO(oshima/stevenjb): Add support for 3+ displays.
+  display_manager_->SetLayoutForCurrentDisplays(layout);
+  if (display_animator_)
+    display_animator_->StartFadeInAnimation();
+}
+
+void DisplayConfigurationController::SetMirrorModeImpl(bool mirror) {
+  display_manager_->SetMirrorMode(mirror);
+  if (limiter_)
+    limiter_->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
+  if (display_animator_)
+    display_animator_->StartFadeInAnimation();
+}
+
+void DisplayConfigurationController::SetPrimaryDisplayIdImpl(
+    int64_t display_id) {
+  window_tree_host_manager_->SetPrimaryDisplayId(display_id);
+  if (limiter_)
+    limiter_->SetThrottleTimeout(kSetPrimaryDisplayThrottleTimeoutMs);
+  if (display_animator_)
+    display_animator_->StartFadeInAnimation();
+}
+
+}  // namespace ash