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

chrome/browser/chromeos/display/display_preferences_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 "chrome/browser/chromeos/display/display_preferences.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <utility>
@@ skipping 33 matching lines @@
 using ash::ResolutionNotificationController;
 
 namespace chromeos {
 namespace {
 const char kPrimaryIdKey[] = "primary-id";
 const char kMirroredKey[] = "mirrored";
 const char kPositionKey[] = "position";
 const char kOffsetKey[] = "offset";
 const char kPlacementDisplayIdKey[] = "placement.display_id";
 const char kPlacementParentDisplayIdKey[] = "placement.parent_display_id";
+const char kTouchCalibrationWidth[] = "touch_calibration_width";
+const char kTouchCalibrationHeight[] = "touch_calibration_height";
+const char* kTouchCalibrationDataKeys[] = {
+    "display_1_x", "display_1_y", "touch_1_x", "touch_1_y",  // Pair 1
+    "display_2_x", "display_2_y", "touch_2_x", "touch_2_y",  // Pair 2
+    "display_3_x", "display_3_y", "touch_3_x", "touch_3_y",  // Pair 3
+    "display_4_x", "display_4_y", "touch_4_x", "touch_4_y"   // Pair 4
+};
 
 // The mean acceleration due to gravity on Earth in m/s^2.
 const float kMeanGravity = -9.80665f;
 
 bool IsRotationLocked() {
   return ash::Shell::GetInstance()
       ->screen_orientation_controller()
       ->rotation_locked();
 }
 
@@ skipping 236 matching lines @@
   EXPECT_NE(dummy_id, display::Screen::GetScreen()->GetPrimaryDisplay().id());
 
   window_tree_host_manager->SetOverscanInsets(id1, gfx::Insets(10, 11, 12, 13));
   display_manager()->SetDisplayRotation(id1, display::Display::ROTATE_90,
                                         display::Display::ROTATION_SOURCE_USER);
   EXPECT_TRUE(display::test::DisplayManagerTestApi(display_manager())
                   .SetDisplayUIScale(id1, 1.25f));
   EXPECT_FALSE(display::test::DisplayManagerTestApi(display_manager())
                    .SetDisplayUIScale(id2, 1.25f));
 
+  // Set touch calibration data for display |id2|.
+  display::TouchCalibrationData::CalibrationPointPairQuad point_pair_quad = {
+      {std::make_pair(gfx::Point(10, 10), gfx::Point(11, 12)),
+       std::make_pair(gfx::Point(190, 10), gfx::Point(195, 8)),
+       std::make_pair(gfx::Point(10, 90), gfx::Point(12, 94)),
+       std::make_pair(gfx::Point(190, 90), gfx::Point(189, 88))}};
+  gfx::Size touch_size(200, 150);
+  display_manager()->SetTouchCalibrationData(id2, point_pair_quad, touch_size);
+
   const base::DictionaryValue* displays =
       local_state()->GetDictionary(prefs::kSecondaryDisplays);
   const base::DictionaryValue* layout_value = nullptr;
   std::string key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
   std::string dummy_key =
       base::Int64ToString(id1) + "," + base::Int64ToString(dummy_id);
   EXPECT_TRUE(displays->GetDictionary(dummy_key, &layout_value));
 
   display::DisplayLayout stored_layout;
   EXPECT_TRUE(ash::JsonToDisplayLayout(*layout_value, &stored_layout));
@@ skipping 27 matching lines @@
   int top = 0, left = 0, bottom = 0, right = 0;
   EXPECT_TRUE(property->GetInteger("insets_top", &top));
   EXPECT_TRUE(property->GetInteger("insets_left", &left));
   EXPECT_TRUE(property->GetInteger("insets_bottom", &bottom));
   EXPECT_TRUE(property->GetInteger("insets_right", &right));
   EXPECT_EQ(10, top);
   EXPECT_EQ(11, left);
   EXPECT_EQ(12, bottom);
   EXPECT_EQ(13, right);
 
+  int x, y;
+  for (std::size_t row = 0; row < point_pair_quad.size(); row++) {
+    EXPECT_FALSE(property->GetInteger(kTouchCalibrationDataKeys[row * 4], &x));
+    EXPECT_FALSE(
+        property->GetInteger(kTouchCalibrationDataKeys[row * 4 + 1], &y));
+    EXPECT_FALSE(
+        property->GetInteger(kTouchCalibrationDataKeys[row * 4 + 2], &x));
+    EXPECT_FALSE(
+        property->GetInteger(kTouchCalibrationDataKeys[row * 4 + 3], &y));
+  }
+  EXPECT_FALSE(property->GetInteger(kTouchCalibrationWidth, &width));
+  EXPECT_FALSE(property->GetInteger(kTouchCalibrationHeight, &height));
+
   std::string color_profile;
   EXPECT_TRUE(property->GetString("color_profile_name", &color_profile));
   EXPECT_EQ("dynamic", color_profile);
 
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
   EXPECT_TRUE(property->GetInteger("rotation", &rotation));
   EXPECT_TRUE(property->GetInteger("ui-scale", &ui_scale));
   EXPECT_EQ(0, rotation);
   // ui_scale works only on 2x scale factor/1st display.
   EXPECT_EQ(1000, ui_scale);
   EXPECT_FALSE(property->GetInteger("insets_top", &top));
   EXPECT_FALSE(property->GetInteger("insets_left", &left));
   EXPECT_FALSE(property->GetInteger("insets_bottom", &bottom));
   EXPECT_FALSE(property->GetInteger("insets_right", &right));
 
+  for (std::size_t row = 0; row < point_pair_quad.size(); row++) {
+    EXPECT_TRUE(property->GetInteger(kTouchCalibrationDataKeys[row * 4], &x));
+    EXPECT_TRUE(
+        property->GetInteger(kTouchCalibrationDataKeys[row * 4 + 1], &y));
+    EXPECT_EQ(point_pair_quad[row].first.x(), x);
+    EXPECT_EQ(point_pair_quad[row].first.y(), y);
+
+    EXPECT_TRUE(
+        property->GetInteger(kTouchCalibrationDataKeys[row * 4 + 2], &x));
+    EXPECT_TRUE(
+        property->GetInteger(kTouchCalibrationDataKeys[row * 4 + 3], &y));
+    EXPECT_EQ(point_pair_quad[row].second.x(), x);
+    EXPECT_EQ(point_pair_quad[row].second.y(), y);
+  }
+  width = height = 0;
+  EXPECT_TRUE(property->GetInteger(kTouchCalibrationWidth, &width));
+  EXPECT_TRUE(property->GetInteger(kTouchCalibrationHeight, &height));
+  EXPECT_EQ(width, touch_size.width());
+  EXPECT_EQ(height, touch_size.height());
+
   // |id2| doesn't have the color_profile because it doesn't have 'dynamic' in
   // its available list.
   EXPECT_FALSE(property->GetString("color_profile_name", &color_profile));
 
   // Resolution is saved only when the resolution is set
   // by DisplayManager::SetDisplayMode
   width = 0;
   height = 0;
   EXPECT_FALSE(property->GetInteger("width", &width));
   EXPECT_FALSE(property->GetInteger("height", &height));
@@ skipping 84 matching lines @@
   // by mirroring.
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
   EXPECT_TRUE(property->GetInteger("width", &width));
   EXPECT_TRUE(property->GetInteger("height", &height));
   EXPECT_EQ(300, width);
   EXPECT_EQ(200, height);
 
   // Set new display's selected resolution.
   display_manager()->RegisterDisplayProperty(
       id2 + 1, display::Display::ROTATE_0, 1.0f, nullptr, gfx::Size(500, 400),
-      1.0f, ui::COLOR_PROFILE_STANDARD);
+      1.0f, ui::COLOR_PROFILE_STANDARD, nullptr);
 
   UpdateDisplay("200x200*2, 600x500#600x500|500x400");
 
   // Update key as the 2nd display gets new id.
   id2 = display_manager()->GetSecondaryDisplay().id();
   key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
   EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
   EXPECT_TRUE(layout_value->GetString(kPositionKey, &position));
   EXPECT_EQ("right", position);
   EXPECT_TRUE(layout_value->GetInteger(kOffsetKey, &offset));
   EXPECT_EQ(0, offset);
   mirrored = true;
   EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
   EXPECT_FALSE(mirrored);
   EXPECT_TRUE(layout_value->GetString(kPrimaryIdKey, &primary_id_str));
   EXPECT_EQ(base::Int64ToString(id1), primary_id_str);
 
   // Best resolution should not be saved.
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id2), &property));
   EXPECT_FALSE(property->GetInteger("width", &width));
   EXPECT_FALSE(property->GetInteger("height", &height));
 
   // Set yet another new display's selected resolution.
   display_manager()->RegisterDisplayProperty(
       id2 + 1, display::Display::ROTATE_0, 1.0f, nullptr, gfx::Size(500, 400),
-      1.0f, ui::COLOR_PROFILE_STANDARD);
+      1.0f, ui::COLOR_PROFILE_STANDARD, nullptr);
   // Disconnect 2nd display first to generate new id for external display.
   UpdateDisplay("200x200*2");
   UpdateDisplay("200x200*2, 500x400#600x500|500x400%60.0f");
   // Update key as the 2nd display gets new id.
   id2 = display_manager()->GetSecondaryDisplay().id();
   key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
   EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
   EXPECT_TRUE(layout_value->GetString(kPositionKey, &position));
   EXPECT_EQ("right", position);
   EXPECT_TRUE(layout_value->GetInteger(kOffsetKey, &offset));
@@ skipping 605 matching lines @@
 
   EXPECT_EQ(gfx::Rect(0, 0, 200, 200),
             display_manager()->GetDisplayForId(list[0]).bounds());
   EXPECT_EQ(gfx::Rect(-200, 0, 200, 200),
             display_manager()->GetDisplayForId(list[1]).bounds());
   EXPECT_EQ(gfx::Rect(-100, 200, 300, 300),
             display_manager()->GetDisplayForId(list[2]).bounds());
 }
 
 }  // namespace chromeos