Introduce DisplayConfigurationController

ash/display/window_tree_host_manager.cc

 // Copyright (c) 2012 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/window_tree_host_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <utility>
@@ skipping 30 matching lines @@
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/compositor/compositor.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/public/activation_client.h"
 
-#if defined(OS_CHROMEOS)
-#include "ash/display/display_animator.h"
-#include "base/sys_info.h"
-#include "base/time/time.h"
-#endif  // defined(OS_CHROMEOS)
-
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/x/x11_types.h"
 
 // Including this at the bottom to avoid other
 // potential conflict with chrome headers.
 #include <X11/extensions/Xrandr.h>
 #undef RootWindow
 #endif  // defined(USE_X11)
 
 #if defined(OS_CHROMEOS) && defined(USE_OZONE)
 #include "ui/events/ozone/chromeos/cursor_controller.h"
 #endif
 
 namespace ash {
 namespace {
 
 // Primary display stored in global object as it can be
 // accessed after Shell is deleted. A separate display instance is created
 // during the shutdown instead of always keeping two display instances
 // (one here and another one in display_manager) in sync, which is error prone.
 // This is initialized in the constructor, and then in CreatePrimaryHost().
 int64_t primary_display_id = -1;
 
-// 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 kSwapDisplayThrottleTimeoutMs = 500;
-
 #if defined(USE_OZONE) && defined(OS_CHROMEOS)
 // Add 20% more cursor motion on non-integrated displays.
 const float kCursorMultiplierForExternalDisplays = 1.2f;
 #endif
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 void SetDisplayPropertiesOnHost(AshWindowTreeHost* ash_host,
@@ skipping 137 matching lines @@
   aura::client::CaptureClient* capture_client_;
   aura::client::FocusClient* focus_client_;
   aura::WindowTracker tracker_;
   aura::Window* focused_;
   aura::Window* active_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusActivationStore);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// DisplayChangeLimiter
-
-WindowTreeHostManager::DisplayChangeLimiter::DisplayChangeLimiter()
-    : throttle_timeout_(base::Time::Now()) {}
-
-void WindowTreeHostManager::DisplayChangeLimiter::SetThrottleTimeout(
-    int64_t throttle_ms) {
-  throttle_timeout_ =
-      base::Time::Now() + base::TimeDelta::FromMilliseconds(throttle_ms);
-}
-
-bool WindowTreeHostManager::DisplayChangeLimiter::IsThrottled() const {
-  return base::Time::Now() < throttle_timeout_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostManager
 
 WindowTreeHostManager::WindowTreeHostManager()
     : primary_tree_host_for_replace_(nullptr),
       focus_activation_store_(new FocusActivationStore()),
       cursor_window_controller_(new CursorWindowController()),
       mirror_window_controller_(new MirrorWindowController()),
       cursor_display_id_for_restore_(gfx::Display::kInvalidDisplayID),
       weak_ptr_factory_(this) {
-#if defined(OS_CHROMEOS)
-  if (base::SysInfo::IsRunningOnChromeOS())
-    limiter_.reset(new DisplayChangeLimiter);
-#endif
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
 }
 
 WindowTreeHostManager::~WindowTreeHostManager() {}
 
 void WindowTreeHostManager::Start() {
   Shell::GetScreen()->AddObserver(this);
   Shell::GetInstance()->display_manager()->set_delegate(this);
@@ skipping 132 matching lines @@
   for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
        it != window_tree_hosts_.end(); ++it) {
     RootWindowController* controller =
         GetRootWindowController(GetWindow(it->second));
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
-void WindowTreeHostManager::ToggleMirrorMode() {
-  DisplayManager* display_manager = GetDisplayManager();
-  if (display_manager->num_connected_displays() <= 1)
+void WindowTreeHostManager::SwapPrimaryDisplayForTest() {
+  if (Shell::GetScreen()->GetNumDisplays() <= 1)
     return;
-
-  if (limiter_) {
-    if (limiter_->IsThrottled())
-      return;
-    limiter_->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
-  }
-#if defined(OS_CHROMEOS)
-  Shell* shell = Shell::GetInstance();
-  DisplayAnimator* animation = shell->display_animator();
-  animation->StartFadeOutAnimation(base::Bind(
-      &WindowTreeHostManager::SetMirrorModeAfterAnimation,
-      weak_ptr_factory_.GetWeakPtr(), !display_manager->IsInMirrorMode()));
-#endif
-}
-
-void WindowTreeHostManager::SwapPrimaryDisplay() {
-  if (limiter_) {
-    if (limiter_->IsThrottled())
-      return;
-    limiter_->SetThrottleTimeout(kSwapDisplayThrottleTimeoutMs);
-  }
-
-  if (Shell::GetScreen()->GetNumDisplays() > 1) {
-#if defined(OS_CHROMEOS)
-    DisplayAnimator* animation = Shell::GetInstance()->display_animator();
-    if (animation) {
-      animation->StartFadeOutAnimation(
-          base::Bind(&WindowTreeHostManager::OnFadeOutForSwapDisplayFinished,
-                     weak_ptr_factory_.GetWeakPtr()));
-    } else {
-      SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
-    }
-#else
-    SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
-#endif
-  }
+  SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
 }
 
 void WindowTreeHostManager::SetPrimaryDisplayId(int64_t id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
   if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id)
     return;
 
   const gfx::Display& display = GetDisplayManager()->GetDisplayForId(id);
   if (display.is_valid())
     SetPrimaryDisplay(display);
@@ skipping 347 matching lines @@
   cursor_display_id_for_restore_ = display.id();
 
   gfx::Point point_in_native = point_in_screen;
   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
   ::wm::ConvertPointFromScreen(root_window, &point_in_native);
   root_window->GetHost()->ConvertPointToNativeScreen(&point_in_native);
   cursor_location_in_native_coords_for_restore_ = point_in_native;
 }
 
 void WindowTreeHostManager::PostDisplayConfigurationChange() {
-  if (limiter_)
-    limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
-
   focus_activation_store_->Restore();
 
   DisplayManager* display_manager = GetDisplayManager();
   DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
     DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
     layout_store->UpdateMultiDisplayState(
         pair, display_manager->IsInMirrorMode(), layout.default_unified);
 
@@ skipping 63 matching lines @@
   window_tree_hosts_[display.id()] = ash_host;
   SetDisplayPropertiesOnHost(ash_host, display);
 
 #if defined(OS_CHROMEOS)
   if (switches::ConstrainPointerToRoot())
     ash_host->ConfineCursorToRootWindow();
 #endif
   return ash_host;
 }
 
-void WindowTreeHostManager::OnFadeOutForSwapDisplayFinished() {
-#if defined(OS_CHROMEOS)
-  SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
-  Shell::GetInstance()->display_animator()->StartFadeInAnimation();
-#endif
-}
-
-void WindowTreeHostManager::SetMirrorModeAfterAnimation(bool mirror) {
-  GetDisplayManager()->SetMirrorMode(mirror);
-}
-
 }  // namespace ash