[WIP][Ozone] Support external touchscreens

ash/touch/touch_transformer_controller_x11.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 "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/root_window_controller.h"
@@ skipping 25 matching lines @@
 double TouchTransformerController::GetTouchResolutionScale(
     const DisplayInfo& touch_display) const {
   if (touch_display.touch_device_id() == 0)
     return 1.0;
 
   double min_x, max_x;
   double min_y, max_y;
   if (!ui::DeviceDataManagerX11::GetInstance()->GetDataRange(
           touch_display.touch_device_id(),
           ui::DeviceDataManagerX11::DT_TOUCH_POSITION_X,
-          &min_x, &max_x) ||
+          &min_x,
+          &max_x) ||
       !ui::DeviceDataManagerX11::GetInstance()->GetDataRange(
           touch_display.touch_device_id(),
           ui::DeviceDataManagerX11::DT_TOUCH_POSITION_Y,
-          &min_y, &max_y)) {
+          &min_y,
+          &max_y)) {
     return 1.0;
   }
 
   double width = touch_display.bounds_in_native().width();
   double height = touch_display.bounds_in_native().height();
 
   if (max_x == 0.0 || max_y == 0.0 || width == 0.0 || height == 0.0)
     return 1.0;
 
   // [0, max_x] -> touchscreen width = max_x + 1
   // [0, max_y] -> touchscreen height = max_y + 1
   max_x += 1.0;
   max_y += 1.0;
 
   double ratio = std::sqrt((width * height) / (max_x * max_y));
 
   VLOG(2) << "Screen width/height: " << width << "/" << height
           << ", Touchscreen width/height: " << max_x << "/" << max_y
           << ", Touch radius scale ratio: " << ratio;
   return ratio;
 }
 
 // This function computes the extended mode TouchTransformer for
 // |touch_display|. The TouchTransformer maps the touch event position
 // from framebuffer size to the display size.
-gfx::Transform
-TouchTransformerController::GetExtendedModeTouchTransformer(
-    const DisplayInfo& touch_display, const gfx::Size& fb_size) const {
+gfx::Transform TouchTransformerController::GetExtendedModeTouchTransformer(
+    const DisplayInfo& touch_display,
+    const gfx::Size& fb_size) const {
   gfx::Transform ctm;
-  if (touch_display.touch_device_id() == 0 ||
-      fb_size.width() == 0.0 ||
+  if (touch_display.touch_device_id() == 0 || fb_size.width() == 0.0 ||
       fb_size.height() == 0.0)
     return ctm;
   float width = touch_display.bounds_in_native().width();
   float height = touch_display.bounds_in_native().height();
   ctm.Scale(width / fb_size.width(), height / fb_size.height());
   return ctm;
 }
 
 bool TouchTransformerController::ShouldComputeMirrorModeTouchTransformer(
     const DisplayInfo& touch_display) const {
@@ skipping 23 matching lines @@
   gfx::Transform ctm;
   if (!ShouldComputeMirrorModeTouchTransformer(touch_display))
     return ctm;
 
   float mirror_width = touch_display.bounds_in_native().width();
   float mirror_height = touch_display.bounds_in_native().height();
   gfx::Size native_mode_size = touch_display.GetNativeModeSize();
   float native_width = native_mode_size.width();
   float native_height = native_mode_size.height();
 
-  if (native_height == 0.0 || mirror_height == 0.0 ||
-      native_width == 0.0 || mirror_width == 0.0)
+  if (native_height == 0.0 || mirror_height == 0.0 || native_width == 0.0 ||
+      mirror_width == 0.0)
     return ctm;
 
   float native_ar = native_width / native_height;
   float mirror_ar = mirror_width / mirror_height;
 
   if (mirror_ar > native_ar) {  // Letterboxing
     // Translate before scale.
     ctm.Translate(0.0, (1.0 - mirror_ar / native_ar) * 0.5 * mirror_height);
     ctm.Scale(1.0, mirror_ar / native_ar);
     return ctm;
   }
 
   if (native_ar > mirror_ar) {  // Pillarboxing
     // Translate before scale.
     ctm.Translate((1.0 - native_ar / mirror_ar) * 0.5 * mirror_width, 0.0);
     ctm.Scale(native_ar / mirror_ar, 1.0);
     return ctm;
   }
 
   return ctm;  // Same aspect ratio - return identity
 }
 
-TouchTransformerController::TouchTransformerController() :
-    force_compute_mirror_mode_touch_transformer_ (false) {
+TouchTransformerController::TouchTransformerController()
+    : force_compute_mirror_mode_touch_transformer_(false) {
   Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 TouchTransformerController::~TouchTransformerController() {
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
 void TouchTransformerController::UpdateTouchTransformer() const {
   ui::DeviceDataManager* device_manager = ui::DeviceDataManager::GetInstance();
   device_manager->ClearTouchTransformerRecord();
@@ skipping 51 matching lines @@
         display2.touch_device_id(),
         GetMirrorModeTouchTransformer(display2));
     return;
   }
 
   if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {
     gfx::Size fb_size =
         Shell::GetInstance()->display_configurator()->framebuffer_size();
     // In extended but software mirroring mode, ther is only one X root window
     // that associates with both displays.
-    if (GetDisplayManager()->software_mirroring_enabled())  {
+    if (GetDisplayManager()->software_mirroring_enabled()) {
       aura::Window* root = display_controller->GetPrimaryRootWindow();
       RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
           display1_id, display2_id);
       DisplayInfo source_display =
-          gfx::Display::InternalDisplayId() == display1_id ?
-          display1 : display2;
+          gfx::Display::InternalDisplayId() == display1_id ? display1
+                                                           : display2;
       // Mapping from framebuffer size to the source display's native
       // resolution.
       device_manager->UpdateTouchInfoForDisplay(
           display1_id,
           display1.touch_device_id(),
           GetExtendedModeTouchTransformer(source_display, fb_size));
       device_manager->UpdateTouchInfoForDisplay(
           display2_id,
           display2.touch_device_id(),
           GetExtendedModeTouchTransformer(source_display, fb_size));
@@ skipping 19 matching lines @@
           GetExtendedModeTouchTransformer(display2, fb_size));
     }
     return;
   }
 
   // Single display mode. The root window has one associated display id.
   aura::Window* root =
       display_controller->GetRootWindowForDisplayId(single_display.id());
   RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
       single_display.id(), gfx::Display::kInvalidDisplayID);
-  device_manager->UpdateTouchInfoForDisplay(single_display_id,
-                                            single_display.touch_device_id(),
-                                            gfx::Transform());
+  device_manager->UpdateTouchInfoForDisplay(
+      single_display_id, single_display.touch_device_id(), gfx::Transform());
 }
 
 void TouchTransformerController::OnDisplaysInitialized() {
   UpdateTouchTransformer();
 }
 
 void TouchTransformerController::OnDisplayConfigurationChanged() {
   UpdateTouchTransformer();
 }
 
 }  // namespace ash