Plumbs touch calibration API to the display manager

chrome/browser/extensions/display_info_provider_chromeos.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 "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "chrome/browser/chromeos/display/overscan_calibrator.h"
+#include "chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_controller.h"
 #include "extensions/common/api/system_display.h"
 #include "ui/display/display.h"
 #include "ui/display/display_layout.h"
 #include "ui/display/display_layout_builder.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
@@ skipping 343 matching lines @@
   result.width_in_native_pixels = display_mode->size().width();
   result.height_in_native_pixels = display_mode->size().height();
   result.ui_scale = display_mode->ui_scale();
   result.device_scale_factor = display_mode->device_scale_factor();
   result.is_native = display_mode->native();
   result.is_selected = display_mode->IsEquivalent(
       display_manager->GetActiveModeForDisplayId(display_info.id()));
   return result;
 }
 
+display::TouchCalibrationData::CalibrationPointPair GetCalibrationPair(
+    const system_display::TouchCalibrationPair& pair) {
+  return std::make_pair(gfx::Point(pair.display_point.x, pair.display_point.y),
+                        gfx::Point(pair.touch_point.x, pair.touch_point.y));
+}
+
+bool ValidateParamsForTouchCalibration(
+    const std::string& id,
+    const display::Display& display,
+    chromeos::TouchCalibratorController* const touch_calibrator_controller,
+    std::string* error) {
+  if (display.id() == display::kInvalidDisplayId) {
+    *error = "Display Id(" + id + ") is an invalid display ID";
+    return false;
+  }
+
+  if (display.IsInternal()) {
+    *error = "Display Id(" + id + ") is an internal display. Internal " +
+             "displays cannot be calibrated for touch.";
+    return false;
+  }
+
+  if (display.touch_support() != display::Display::TOUCH_SUPPORT_AVAILABLE) {
+    *error = "Display Id(" + id + ") does not support touch.";
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace
 
 DisplayInfoProviderChromeOS::DisplayInfoProviderChromeOS() {}
 
 DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() {}
 
 bool DisplayInfoProviderChromeOS::SetInfo(
     const std::string& display_id_str,
     const system_display::DisplayProperties& info,
     std::string* error) {
@@ skipping 204 matching lines @@
           display.id());
   overscan_calibrators_[id].reset(
       new chromeos::OverscanCalibrator(display, insets));
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::OverscanCalibrationAdjust(
     const std::string& id,
     const system_display::Insets& delta) {
   VLOG(1) << "OverscanCalibrationAdjust: " << id;
-  chromeos::OverscanCalibrator* calibrator = GetCalibrator(id);
+  chromeos::OverscanCalibrator* calibrator = GetOverscanCalibrator(id);
   if (!calibrator)
     return false;
   gfx::Insets insets = calibrator->insets();
   insets += gfx::Insets(delta.top, delta.left, delta.bottom, delta.right);
   calibrator->UpdateInsets(insets);
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::OverscanCalibrationReset(
     const std::string& id) {
   VLOG(1) << "OverscanCalibrationReset: " << id;
-  chromeos::OverscanCalibrator* calibrator = GetCalibrator(id);
+  chromeos::OverscanCalibrator* calibrator = GetOverscanCalibrator(id);
   if (!calibrator)
     return false;
   calibrator->Reset();
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::OverscanCalibrationComplete(
     const std::string& id) {
   VLOG(1) << "OverscanCalibrationComplete: " << id;
-  chromeos::OverscanCalibrator* calibrator = GetCalibrator(id);
+  chromeos::OverscanCalibrator* calibrator = GetOverscanCalibrator(id);
   if (!calibrator)
     return false;
   calibrator->Commit();
   overscan_calibrators_[id].reset();
   return true;
 }
 
-chromeos::OverscanCalibrator* DisplayInfoProviderChromeOS::GetCalibrator(
-    const std::string& id) {
+bool DisplayInfoProviderChromeOS::TouchCalibrationSet(
+    const std::string& id,
+    const api::system_display::TouchCalibrationPairQuad& pairs,
+    const api::system_display::Bounds& bounds,
+    std::string* error) {
+  VLOG(1) << "TouchCalibrationSet: " << id;
+
+  const display::Display display = GetDisplay(id);
+  if (!ValidateParamsForTouchCalibration(id, display, GetTouchCalibrator(),
+                                         error)) {
+    return false;
+  }
+
+  display::TouchCalibrationData::CalibrationPointPairQuad calibration_points;
+  calibration_points[0] = GetCalibrationPair(pairs.pair1);
+  calibration_points[1] = GetCalibrationPair(pairs.pair2);
+  calibration_points[2] = GetCalibrationPair(pairs.pair3);
+  calibration_points[3] = GetCalibrationPair(pairs.pair4);
+
+  // The display bounds cannot have negative values.
+  if (bounds.width < 0 || bounds.height < 0) {
+    *error = "Bounds cannot have negative values.";
+    return false;
+  }
+
+  for (size_t row = 0; row < calibration_points.size(); row++) {
+    // Coordinates for display and touch point cannot be negative.
+    if (calibration_points[row].first.x() < 0 ||
+        calibration_points[row].first.y() < 0 ||
+        calibration_points[row].second.x() < 0 ||
+        calibration_points[row].second.y() < 0) {
+      *error = "Display points and touch points cannot have negative "
+               "coordinates";
+      return false;
+    }
+    // Coordinates for display points cannot be greater than the screen bounds.
+    if (calibration_points[row].first.x() > bounds.width ||
+        calibration_points[row].first.y() > bounds.height) {
+      *error = "Display point coordinates cannot be more than size of the "
+               "display.";
+      return false;
+    }
+  }
+
+  gfx::Size display_size(bounds.width, bounds.height);
+  ash::Shell::GetInstance()->display_manager()->SetTouchCalibrationData(
+      display.id(), calibration_points, display_size);
+  return true;
+}
+
+bool DisplayInfoProviderChromeOS::TouchCalibrationReset(const std::string& id,
+                                                        std::string* error) {
+  const display::Display display = GetDisplay(id);
+
+  if (!ValidateParamsForTouchCalibration(id, display, GetTouchCalibrator(),
+                                         error)) {
+    return false;
+  }
+
+  ash::Shell::GetInstance()->display_manager()->ClearTouchCalibrationData(
+      display.id());
+  return true;
+}
+
+bool DisplayInfoProviderChromeOS::IsTouchCalibrationActive(std::string* error) {
+  if (GetTouchCalibrator()->is_calibrating()) {
+    *error = "Another touch calibration is already active.";
+    return true;
+  }
+  return false;
+}
+
+chromeos::OverscanCalibrator*
+DisplayInfoProviderChromeOS::GetOverscanCalibrator(const std::string& id) {
   auto iter = overscan_calibrators_.find(id);
   if (iter == overscan_calibrators_.end())
     return nullptr;
   return iter->second.get();
 }
 
+chromeos::TouchCalibratorController*
+DisplayInfoProviderChromeOS::GetTouchCalibrator() {
+  if (!touch_calibrator_)
+    touch_calibrator_.reset(new chromeos::TouchCalibratorController);
+  return touch_calibrator_.get();
+}
+
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions