Move TouchTransformerController to ui/display/.

ui/display/manager/chromeos/touch_transform_controller.cc

 // Copyright 2014 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/touch/touch_transformer_controller.h"
+#include "ui/display/manager/chromeos/touch_transform_controller.h"
 
-#include "ash/display/window_tree_host_manager.h"
-#include "ash/host/ash_window_tree_host.h"
-#include "ash/root_window_controller.h"
-#include "ash/shell.h"
+#include <utility>
+#include <vector>
+
 #include "third_party/skia/include/core/SkMatrix44.h"
-#include "ui/aura/window_tree_host.h"
 #include "ui/display/display_layout.h"
 #include "ui/display/manager/chromeos/display_configurator.h"
 #include "ui/display/manager/display_manager.h"
+#include "ui/display/manager/managed_display_info.h"
+#include "ui/display/screen.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/events/devices/device_data_manager.h"
 
-namespace ash {
+namespace display {
 
 namespace {
 
-display::DisplayManager* GetDisplayManager() {
-  return Shell::GetInstance()->display_manager();
-}
-
 ui::TouchscreenDevice FindTouchscreenById(int id) {
   const std::vector<ui::TouchscreenDevice>& touchscreens =
       ui::DeviceDataManager::GetInstance()->GetTouchscreenDevices();
   for (const auto& touchscreen : touchscreens) {
     if (touchscreen.id == id)
       return touchscreen;
   }
 
   return ui::TouchscreenDevice();
 }
@@ skipping 77 matching lines @@
 
   // Create a transform matrix using the touch calibration data.
   ctm->ConcatTransform(gfx::Transform(
       x_constants.fData[0], x_constants.fData[1], 0, x_constants.fData[2],
       y_constants.fData[0], y_constants.fData[1], 0, y_constants.fData[2], 0, 0,
       1, 0, 0, 0, 0, 1));
   return true;
 }
 
 // Returns an uncalibrated touch transform.
-gfx::Transform GetUncalibratedTransform(
-    const gfx::Transform& tm,
-    const display::ManagedDisplayInfo& display,
-    const display::ManagedDisplayInfo& touch_display,
-    const gfx::SizeF& touch_area,
-    const gfx::SizeF& touch_native_size) {
+gfx::Transform GetUncalibratedTransform(const gfx::Transform& tm,
+                                        const ManagedDisplayInfo& display,
+                                        const ManagedDisplayInfo& touch_display,
+                                        const gfx::SizeF& touch_area,
+                                        const gfx::SizeF& touch_native_size) {
   gfx::SizeF current_size(display.bounds_in_native().size());
   gfx::Transform ctm(tm);
   // Take care of panel fitting only if supported. Panel fitting is emulated
   // in software mirroring mode (display != touch_display).
   // If panel fitting is enabled then the aspect ratio is preserved and the
   // display is scaled acordingly. In this case blank regions would be present
   // in order to center the displayed area.
   if (display.is_aspect_preserving_scaling() ||
       display.id() != touch_display.id()) {
     float touch_calib_ar =
@@ skipping 19 matching lines @@
 }  // namespace
 
 // This is to compute the scale ratio for the TouchEvent's radius. The
 // configured resolution of the display is not always the same as the touch
 // screen's reporting resolution, e.g. the display could be set as
 // 1920x1080 while the touchscreen is reporting touch position range at
 // 32767x32767. Touch radius is reported in the units the same as touch position
 // so we need to scale the touch radius to be compatible with the display's
 // resolution. We compute the scale as
 // sqrt of (display_area / touchscreen_area)
-double TouchTransformerController::GetTouchResolutionScale(
-    const display::ManagedDisplayInfo& touch_display,
+double TouchTransformController::GetTouchResolutionScale(
+    const ManagedDisplayInfo& touch_display,
     const ui::TouchscreenDevice& touch_device) const {
   if (touch_device.id == ui::InputDevice::kInvalidId ||
       touch_device.size.IsEmpty() ||
       touch_display.bounds_in_native().size().IsEmpty())
     return 1.0;
 
   double display_area = touch_display.bounds_in_native().size().GetArea();
   double touch_area = touch_device.size.GetArea();
   double ratio = std::sqrt(display_area / touch_area);
 
   VLOG(2) << "Display size: "
           << touch_display.bounds_in_native().size().ToString()
           << ", Touchscreen size: " << touch_device.size.ToString()
           << ", Touch radius scale ratio: " << ratio;
   return ratio;
 }
 
-gfx::Transform TouchTransformerController::GetTouchTransform(
-    const display::ManagedDisplayInfo& display,
-    const display::ManagedDisplayInfo& touch_display,
+gfx::Transform TouchTransformController::GetTouchTransform(
+    const ManagedDisplayInfo& display,
+    const ManagedDisplayInfo& touch_display,
     const ui::TouchscreenDevice& touchscreen,
     const gfx::Size& framebuffer_size) const {
   auto current_size = gfx::SizeF(display.bounds_in_native().size());
   auto touch_native_size = gfx::SizeF(touch_display.GetNativeModeSize());
 #if defined(USE_OZONE)
   auto touch_area = gfx::SizeF(touchscreen.size);
 #elif defined(USE_X11)
   // On X11 touches are reported in the framebuffer coordinate space.
   auto touch_area = gfx::SizeF(framebuffer_size);
 #endif
@@ skipping 54 matching lines @@
   // Solve for coefficients and compute transform matrix.
   gfx::Transform stored_ctm;
   if (!GetCalibratedTransform(
           touch_display.GetTouchCalibrationData().point_pairs, pre_transform,
           &stored_ctm)) {
     // TODO(malaykeshav): This can be checked at the calibration step before
     // storing the calibration associated data. This will allow us to explicitly
     // inform the user with proper UX.
 
     // Clear stored calibration data.
-    GetDisplayManager()->ClearTouchCalibrationData(touch_display.id());
+    display_manager_->ClearTouchCalibrationData(touch_display.id());
 
     // Return uncalibrated transform.
     return GetUncalibratedTransform(ctm, display, touch_display, touch_area,
                                     touch_native_size);
   }
 
   stored_ctm.ConcatTransform(ctm);
   return stored_ctm;
 }
 
-TouchTransformerController::TouchTransformerController() {
-  Shell::GetInstance()->window_tree_host_manager()->AddObserver(this);
-}
+TouchTransformController::TouchTransformController(
+    DisplayConfigurator* display_configurator,
+    DisplayManager* display_manager)
+    : display_configurator_(display_configurator),
+      display_manager_(display_manager) {}
 
-TouchTransformerController::~TouchTransformerController() {
-  Shell::GetInstance()->window_tree_host_manager()->RemoveObserver(this);
-}
+TouchTransformController::~TouchTransformController() {}
 
-void TouchTransformerController::UpdateTouchRadius(
-    const display::ManagedDisplayInfo& display) const {
+void TouchTransformController::UpdateTouchRadius(
+    const ManagedDisplayInfo& display) const {
   ui::DeviceDataManager* device_manager = ui::DeviceDataManager::GetInstance();
   for (const auto& device_id : display.input_devices()) {
     device_manager->UpdateTouchRadiusScale(
         device_id,
         GetTouchResolutionScale(display, FindTouchscreenById(device_id)));
   }
 }
 
-void TouchTransformerController::UpdateTouchTransform(
+void TouchTransformController::UpdateTouchTransform(
     int64_t target_display_id,
-    const display::ManagedDisplayInfo& touch_display,
-    const display::ManagedDisplayInfo& target_display) const {
+    const ManagedDisplayInfo& touch_display,
+    const ManagedDisplayInfo& target_display) const {
   ui::DeviceDataManager* device_manager = ui::DeviceDataManager::GetInstance();
-  gfx::Size fb_size =
-      Shell::GetInstance()->display_configurator()->framebuffer_size();
+  gfx::Size fb_size = display_configurator_->framebuffer_size();
   for (const auto& device_id : touch_display.input_devices()) {
     device_manager->UpdateTouchInfoForDisplay(
         target_display_id, device_id,
         GetTouchTransform(target_display, touch_display,
                           FindTouchscreenById(device_id), fb_size));
   }
 }
 
-void TouchTransformerController::UpdateTouchTransformer() const {
-  ui::DeviceDataManager* device_manager = ui::DeviceDataManager::GetInstance();
-  device_manager->ClearTouchDeviceAssociations();
+void TouchTransformController::UpdateTouchTransforms() const {
+  ui::DeviceDataManager::GetInstance()->ClearTouchDeviceAssociations();
 
-  // Display IDs and display::ManagedDisplayInfo for mirror or extended mode.
-  int64_t display1_id = display::kInvalidDisplayId;
-  int64_t display2_id = display::kInvalidDisplayId;
-  display::ManagedDisplayInfo display1;
-  display::ManagedDisplayInfo display2;
-  // Display ID and display::ManagedDisplayInfo for single display mode.
-  int64_t single_display_id = display::kInvalidDisplayId;
-  display::ManagedDisplayInfo single_display;
+  // Display IDs and ManagedDisplayInfo for mirror or extended mode.
+  int64_t display1_id = kInvalidDisplayId;
+  int64_t display2_id = kInvalidDisplayId;
+  ManagedDisplayInfo display1;
+  ManagedDisplayInfo display2;
+  // Display ID and ManagedDisplayInfo for single display mode.
+  int64_t single_display_id = kInvalidDisplayId;
+  ManagedDisplayInfo single_display;
 
-  WindowTreeHostManager* window_tree_host_manager =
-      Shell::GetInstance()->window_tree_host_manager();
-  display::DisplayManager* display_manager = GetDisplayManager();
-  if (display_manager->num_connected_displays() == 0) {
+  if (display_manager_->num_connected_displays() == 0) {
     return;
-  } else if (display_manager->num_connected_displays() == 1 ||
-             display_manager->IsInUnifiedMode()) {
-    single_display_id = display_manager->first_display_id();
-    DCHECK(single_display_id != display::kInvalidDisplayId);
-    single_display = display_manager->GetDisplayInfo(single_display_id);
+  } else if (display_manager_->num_connected_displays() == 1 ||
+             display_manager_->IsInUnifiedMode()) {
+    single_display_id = display_manager_->first_display_id();
+    DCHECK(single_display_id != kInvalidDisplayId);
+    single_display = display_manager_->GetDisplayInfo(single_display_id);
     UpdateTouchRadius(single_display);
   } else {
-    display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
+    DisplayIdList list = display_manager_->GetCurrentDisplayIdList();
     display1_id = list[0];
     display2_id = list[1];
-    DCHECK(display1_id != display::kInvalidDisplayId &&
-           display2_id != display::kInvalidDisplayId);
-    display1 = display_manager->GetDisplayInfo(display1_id);
-    display2 = display_manager->GetDisplayInfo(display2_id);
+    DCHECK(display1_id != kInvalidDisplayId &&
+           display2_id != kInvalidDisplayId);
+    display1 = display_manager_->GetDisplayInfo(display1_id);
+    display2 = display_manager_->GetDisplayInfo(display2_id);
     UpdateTouchRadius(display1);
     UpdateTouchRadius(display2);
   }
 
-  if (display_manager->IsInMirrorMode()) {
-    int64_t primary_display_id =
-        window_tree_host_manager->GetPrimaryDisplayId();
-    if (GetDisplayManager()->SoftwareMirroringEnabled()) {
+  if (display_manager_->IsInMirrorMode()) {
+    int64_t primary_display_id = Screen::GetScreen()->GetPrimaryDisplay().id();
+    if (display_manager_->SoftwareMirroringEnabled()) {
       // In extended but software mirroring mode, there is a WindowTreeHost for
       // each display, but all touches are forwarded to the primary root
       // window's WindowTreeHost.
-      display::ManagedDisplayInfo target_display =
+      ManagedDisplayInfo target_display =
           primary_display_id == display1_id ? display1 : display2;
       UpdateTouchTransform(target_display.id(), display1, target_display);
       UpdateTouchTransform(target_display.id(), display2, target_display);
     } else {
       // In mirror mode, there is just one WindowTreeHost and two displays. Make
       // the WindowTreeHost accept touch events from both displays.
       UpdateTouchTransform(primary_display_id, display1, display1);
       UpdateTouchTransform(primary_display_id, display2, display2);
     }
     return;
   }
 
-  if (display_manager->num_connected_displays() > 1) {
+  if (display_manager_->num_connected_displays() > 1) {
     // In actual extended mode, each display is associated with one
     // WindowTreeHost.
     UpdateTouchTransform(display1_id, display1, display1);
     UpdateTouchTransform(display2_id, display2, display2);
     return;
   }
 
   // Single display mode. The WindowTreeHost has one associated display id.
   UpdateTouchTransform(single_display_id, single_display, single_display);
 }
 
-void TouchTransformerController::OnDisplaysInitialized() {
-  UpdateTouchTransformer();
-}
-
-void TouchTransformerController::OnDisplayConfigurationChanged() {
-  UpdateTouchTransformer();
-}
-
-}  // namespace ash
+}  // namespace display