Updates display manager and display preferences to handle touch calibration data.

ash/display/display_manager_unittest.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 "ui/display/manager/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands_aura.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/display/display_configuration_controller.h"
@@ skipping 610 matching lines @@
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(1, 0, 0, 0));
   EXPECT_EQ(1u, changed().size());
   EXPECT_EQ(display2_id, changed()[0].id());
 
   reset();
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(0, 0, 0, 0));
   EXPECT_EQ(1u, changed().size());
   EXPECT_EQ(display2_id, changed()[0].id());
 }
 
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, TouchCalibrationTest) {
+  if (!SupportsMultipleDisplays())
+    return;
+
+  UpdateDisplay("0+0-500x500,0+501-1024x600");
+  reset();
+
+  ASSERT_EQ(2u, display_manager()->GetNumDisplays());
+  const display::ManagedDisplayInfo display_info1 = GetDisplayInfoAt(0);
+  const display::ManagedDisplayInfo display_info2 = GetDisplayInfoAt(1);
+
+  EXPECT_FALSE(display_info2.has_touch_calibration_data());
+
+  display::TouchCalibrationData::CalibrationPointPairQuad point_pair_quad = {
+      {std::make_pair(gfx::Point(50, 50), gfx::Point(43, 51)),
+       std::make_pair(gfx::Point(950, 50), gfx::Point(975, 45)),
+       std::make_pair(gfx::Point(50, 550), gfx::Point(48, 534)),
+       std::make_pair(gfx::Point(950, 550), gfx::Point(967, 574))}};
+  gfx::Size bounds_at_calibration(display_info2.size_in_pixel());
+  const display::TouchCalibrationData touch_data(point_pair_quad,
+                                                 bounds_at_calibration);
+
+  // Set the touch calibration data for the secondary display.
+  display_manager()->SetTouchCalibrationData(
+      display_info2.id(), point_pair_quad, bounds_at_calibration);
+
+  display::ManagedDisplayInfo updated_display_info2 = GetDisplayInfoAt(1);
+  EXPECT_TRUE(updated_display_info2.has_touch_calibration_data());
+  EXPECT_EQ(touch_data, updated_display_info2.GetTouchCalibrationData());
+
+  // Clearing touch calibration data from the secondary display.
+  display_manager()->ClearTouchCalibrationData(display_info2.id());
+  updated_display_info2 = GetDisplayInfoAt(1);
+  EXPECT_FALSE(updated_display_info2.has_touch_calibration_data());
+
+  // Make sure that SetTouchCalibrationData() is idempotent.
+  display::TouchCalibrationData::CalibrationPointPairQuad point_pair_quad_2 =
+      point_pair_quad;
+  point_pair_quad_2[1] =
+      std::make_pair(gfx::Point(950, 50), gfx::Point(975, 53));
+  display::TouchCalibrationData touch_data_2(point_pair_quad_2,
+                                             bounds_at_calibration);
+  display_manager()->SetTouchCalibrationData(
+      display_info2.id(), point_pair_quad_2, bounds_at_calibration);
+
+  updated_display_info2 = GetDisplayInfoAt(1);
+  EXPECT_TRUE(updated_display_info2.has_touch_calibration_data());
+  EXPECT_EQ(touch_data_2, updated_display_info2.GetTouchCalibrationData());
+
+  display_manager()->SetTouchCalibrationData(
+      display_info2.id(), point_pair_quad, bounds_at_calibration);
+  EXPECT_TRUE(updated_display_info2.has_touch_calibration_data());
+  EXPECT_EQ(touch_data_2, updated_display_info2.GetTouchCalibrationData());
+
+  // Recreate a new 2nd display. It won't apply the touhc calibration data
+  // because the new display has a different ID.
+  UpdateDisplay("0+0-500x500");
+  UpdateDisplay("0+0-500x500,0+501-400x400");
+  EXPECT_FALSE(GetDisplayInfoAt(1).has_touch_calibration_data());
+
+  // Recreate the displays with the same ID.  It should apply the touch
+  // calibration associated data.
+  UpdateDisplay("0+0-500x500");
+  std::vector<display::ManagedDisplayInfo> display_info_list;
+  display_info_list.push_back(display_info1);
+  display_info_list.push_back(display_info2);
+  display_manager()->OnNativeDisplaysChanged(display_info_list);
+  updated_display_info2 = GetDisplayInfoAt(1);
+
+  EXPECT_FALSE(updated_display_info2.has_touch_calibration_data());
+  EXPECT_EQ(touch_data, updated_display_info2.GetTouchCalibrationData());
+}
+#endif  // defined(OS_CHROMEOS)
+
 #if !defined(OS_WIN)
 // Disabled on windows because of http://crbug.com/650326.
 TEST_P(DisplayManagerTest, TestDeviceScaleOnlyChange) {
   UpdateDisplay("1000x600");
   aura::WindowTreeHost* host = Shell::GetPrimaryRootWindow()->GetHost();
   EXPECT_EQ(1, host->compositor()->device_scale_factor());
   EXPECT_EQ("1000x600",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   EXPECT_EQ("1 0 0", GetCountSummary());
 
@@ skipping 823 matching lines @@
 // the internal display.
 TEST_P(DisplayManagerTest, FHD125DefaultsTo08UIScalingNoOverride) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   display_id++;
   display::test::ScopedSetInternalDisplayId set_internal(display_manager(),
                                                          display_id);
   const gfx::Insets dummy_overscan_insets;
   display_manager()->RegisterDisplayProperty(
       display_id, display::Display::ROTATE_0, 1.0f, &dummy_overscan_insets,
-      gfx::Size(), 1.0f, ui::ColorCalibrationProfile());
+      gfx::Size(), 1.0f, ui::ColorCalibrationProfile(), nullptr);
 
   // Setup the display modes with UI-scale.
   display::ManagedDisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
   const scoped_refptr<display::ManagedDisplayMode>& base_mode(
       new display::ManagedDisplayMode(gfx::Size(1920, 1080), 60.0f, false,
                                       false));
   display::ManagedDisplayInfo::ManagedDisplayModeList mode_list =
@@ skipping 937 matching lines @@
 
   ASSERT_DOUBLE_EQ(
       1.25f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_P(DisplayManagerTest, CheckInitializationOfRotationProperty) {
   int64_t id = display_manager()->GetDisplayAt(0).id();
-  display_manager()->RegisterDisplayProperty(id, display::Display::ROTATE_90,
-                                             1.0f, nullptr, gfx::Size(), 1.0f,
-                                             ui::COLOR_PROFILE_STANDARD);
+  display_manager()->RegisterDisplayProperty(
+      id, display::Display::ROTATE_90, 1.0f, nullptr, gfx::Size(), 1.0f,
+      ui::COLOR_PROFILE_STANDARD, nullptr);
 
   const display::ManagedDisplayInfo& info =
       display_manager()->GetDisplayInfo(id);
 
   EXPECT_EQ(display::Display::ROTATE_90,
             info.GetRotation(display::Display::ROTATION_SOURCE_USER));
   EXPECT_EQ(display::Display::ROTATE_90,
             info.GetRotation(display::Display::ROTATION_SOURCE_ACTIVE));
 }
 
@@ skipping 37 matching lines @@
   const display::DisplayLayout& stored =
       layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash