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

ui/display/manager/display_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 "ui/display/manager/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 374 matching lines @@
   return resolution_changed || display_property_changed;
 }
 
 void DisplayManager::RegisterDisplayProperty(
     int64_t display_id,
     Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets,
     const gfx::Size& resolution_in_pixels,
     float device_scale_factor,
-    ui::ColorCalibrationProfile color_profile) {
+    ui::ColorCalibrationProfile color_profile,
+    const TouchCalibrationData* touch_calibration_data) {
   if (display_info_.find(display_id) == display_info_.end())
     display_info_[display_id] =
         ManagedDisplayInfo(display_id, std::string(), false);
 
   // Do not allow rotation in unified desktop mode.
   if (display_id == kUnifiedDisplayId)
     rotation = Display::ROTATE_0;
 
   display_info_[display_id].SetRotation(rotation,
                                         Display::ROTATION_SOURCE_USER);
   display_info_[display_id].SetRotation(rotation,
                                         Display::ROTATION_SOURCE_ACTIVE);
   display_info_[display_id].SetColorProfile(color_profile);
   // Just in case the preference file was corrupted.
   // TODO(mukai): register |display_modes_| here as well, so the lookup for the
   // default mode in GetActiveModeForDisplayId() gets much simpler.
   if (0.5f <= ui_scale && ui_scale <= 2.0f)
     display_info_[display_id].set_configured_ui_scale(ui_scale);
   if (overscan_insets)
     display_info_[display_id].SetOverscanInsets(*overscan_insets);
+  if (touch_calibration_data)
+    display_info_[display_id].SetTouchCalibrationData(*touch_calibration_data);
   if (!resolution_in_pixels.IsEmpty()) {
     DCHECK(!Display::IsInternalDisplayId(display_id));
     // Default refresh rate, until OnNativeDisplaysChanged() updates us with the
     // actual display info, is 60 Hz.
     scoped_refptr<ManagedDisplayMode> mode = new ManagedDisplayMode(
         resolution_in_pixels, 60.0f, false, false, 1.0, device_scale_factor);
     display_modes_[display_id] = mode;
   }
 }
 
@@ skipping 549 matching lines @@
 
 #if defined(OS_CHROMEOS)
 void DisplayManager::SetSoftwareMirroring(bool enabled) {
   SetMultiDisplayMode(enabled ? MIRRORING
                               : current_default_multi_display_mode_);
 }
 
 bool DisplayManager::SoftwareMirroringEnabled() const {
   return software_mirroring_enabled();
 }
+
+void DisplayManager::SetTouchCalibrationData(
+    int64_t display_id,
+    const TouchCalibrationData::CalibrationPointPairQuad& point_pair_quad,
+    const gfx::Size& display_bounds) {
+  bool update = false;
+  TouchCalibrationData calibration_data(point_pair_quad, display_bounds);
+  DisplayInfoList display_info_list;
+  for (const auto& display : active_display_list_) {
+    display::ManagedDisplayInfo info = GetDisplayInfo(display.id());
+    if (info.id() == display_id) {
+      info.SetTouchCalibrationData(calibration_data);
+      update = true;
+    }
+    display_info_list.push_back(info);
+  }

[oshima, 2016/12/02 22:33:41]

can should be able to do somethign like

Display* display = DisplayManager::FindDisplayForId(display_id);
if (dispay) {
  display::ManagedDisplayinfo info = GetDisplayInfo();
  DCHECK(info must be valid)
} else {
   just updat the table.
}

[malaykeshav, 2016/12/03 02:01:28]

We would still need to iterate through |active_display_list_| to create
display_info_list and call UpdateDisplaysWith().
Keeping this as.

[oshima, 2016/12/05 20:43:21]

ah right. please disregard this.

+  if (update)
+    UpdateDisplaysWith(display_info_list);
+  else
+    display_info_[display_id].SetTouchCalibrationData(calibration_data);
+}
+
+void DisplayManager::ClearTouchCalibrationData(int64_t display_id) {
+  bool update = false;
+  DisplayInfoList display_info_list;
+  for (const auto& display : active_display_list_) {
+    display::ManagedDisplayInfo info = GetDisplayInfo(display.id());
+    if (info.id() == display_id) {
+      info.clear_touch_calibration_data();
+      update = true;
+    }
+    display_info_list.push_back(info);
+  }
+  if (update)
+    UpdateDisplaysWith(display_info_list);
+  else
+    display_info_[display_id].clear_touch_calibration_data();
+}
 #endif
 
 void DisplayManager::SetDefaultMultiDisplayModeForCurrentDisplays(
     MultiDisplayMode mode) {
   DCHECK_NE(MIRRORING, mode);
   DisplayIdList list = GetCurrentDisplayIdList();
   layout_store_->UpdateMultiDisplayState(list, IsInMirrorMode(),
                                          mode == UNIFIED);
   ReconfigureDisplays();
 }
@@ skipping 398 matching lines @@
 }
 
 const Display& DisplayManager::GetSecondaryDisplay() const {
   CHECK_LE(2U, GetNumDisplays());
   return GetDisplayAt(0).id() == Screen::GetScreen()->GetPrimaryDisplay().id()
              ? GetDisplayAt(1)
              : GetDisplayAt(0);
 }
 
 }  // namespace display