Moving input device hotplug event processing outside of ui/display

ash/display/display_change_observer_chromeos.cc

 // Copyright 2013 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/display/display_change_observer_chromeos.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
+#include "ash/touch/touchscreen_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/display/types/chromeos/display_mode.h"
 #include "ui/display/types/chromeos/display_snapshot.h"
 #include "ui/display/util/display_util.h"
+#include "ui/events/device_data_manager.h"
+#include "ui/events/touchscreen_device.h"
 #include "ui/gfx/display.h"
 
 namespace ash {
 
 using ui::DisplayConfigurator;
 
 namespace {
 
 // The DPI threshold to determine the device scale factor.
 // DPI higher than |dpi| will use |device_scale_factor|.
@@ skipping 105 matching lines @@
     }
   }
 
   std::sort(
       display_mode_list.begin(), display_mode_list.end(), DisplayModeSorter());
   return display_mode_list;
 }
 
 DisplayChangeObserver::DisplayChangeObserver() {
   Shell::GetInstance()->AddShellObserver(this);
+  ui::DeviceDataManager::GetInstance()->AddObserver(this);
 }
 
 DisplayChangeObserver::~DisplayChangeObserver() {
+  ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds(
     const std::vector<int64>& display_ids) const {
   CHECK_EQ(2U, display_ids.size());
   DisplayIdPair pair = std::make_pair(display_ids[0], display_ids[1]);
   DisplayLayout layout = Shell::GetInstance()->display_manager()->
       layout_store()->GetRegisteredDisplayLayout(pair);
   return layout.mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR :
@@ skipping 52 matching lines @@
 
     bool has_overscan = state.display->has_overscan();
     int64 id = state.display->display_id();
     ids.insert(id);
 
     displays.push_back(DisplayInfo(id, name, has_overscan));
     DisplayInfo& new_info = displays.back();
     new_info.set_device_scale_factor(device_scale_factor);
     new_info.SetBounds(display_bounds);
     new_info.set_native(true);
-    new_info.set_touch_support(state.touch_device_id == 0 ?
-        gfx::Display::TOUCH_SUPPORT_UNAVAILABLE :
-        gfx::Display::TOUCH_SUPPORT_AVAILABLE);
-    new_info.set_touch_device_id(state.touch_device_id);
     new_info.set_is_aspect_preserving_scaling(
         state.display->is_aspect_preserving_scaling());
 
     std::vector<DisplayMode> display_modes =
         (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) ?
         GetInternalDisplayModeList(new_info, state) :
         GetExternalDisplayModeList(state);
     new_info.set_display_modes(display_modes);
 
     new_info.set_available_color_profiles(
         Shell::GetInstance()
             ->display_configurator()
             ->GetAvailableColorCalibrationProfiles(id));
   }
 
+  AssociateTouchscreens(&displays);
   // DisplayManager can be null during the boot.
   Shell::GetInstance()->display_manager()->OnNativeDisplaysChanged(displays);
 }
 
 void DisplayChangeObserver::OnAppTerminating() {
 #if defined(USE_ASH)
   // Stop handling display configuration events once the shutdown
   // process starts. crbug.com/177014.
   Shell::GetInstance()->display_configurator()->PrepareForExit();
 #endif
 }
 
 // static
 float DisplayChangeObserver::FindDeviceScaleFactor(float dpi) {
   for (size_t i = 0; i < arraysize(kThresholdTable); ++i) {
     if (dpi > kThresholdTable[i].dpi)
       return kThresholdTable[i].device_scale_factor;
   }
   return 1.0f;
 }
 
+void DisplayChangeObserver::OnInputDeviceConfigurationChanged() {
+  std::vector<DisplayInfo> display_infos;
+  DisplayManager* display_manager =
+      ash::Shell::GetInstance()->display_manager();
+  const std::vector<gfx::Display>& displays = display_manager->displays();
+  // Reuse the current state in DisplayManager and re-associate the displays
+  // with the touchscreens.
+  for (size_t i = 0; i < displays.size(); ++i) {
+    DisplayInfo display = display_manager->GetDisplayInfo(displays[i].id());
+    // Unset the touchscreen configuration since we'll be rematching them from
+    // scratch.
+    display.set_touch_device_id(ui::TouchscreenDevice::kInvalidId);
+    display.set_touch_support(gfx::Display::TOUCH_SUPPORT_UNKNOWN);
+
+    display_infos.push_back(display);
+  }
+
+  AssociateTouchscreens(&display_infos);
+  display_manager->OnNativeDisplaysChanged(display_infos);
+}
+
 }  // namespace ash