Moving input device hotplug event processing outside of ui/display

ui/display/chromeos/display_configurator.h

 // 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.
 
 #ifndef UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 #define UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 24 matching lines @@
 class DISPLAY_EXPORT DisplayConfigurator : public NativeDisplayObserver {
  public:
   typedef uint64_t ContentProtectionClientId;
   static const ContentProtectionClientId kInvalidClientId = 0;
 
   struct DisplayState {
     DisplayState();
 
     DisplaySnapshot* display;  // Not owned.
 
-    // XInput device ID or 0 if this display isn't a touchscreen.
-    int touch_device_id;
-
     // User-selected mode for the display.
     const DisplayMode* selected_mode;
 
     // Mode used when displaying the same desktop on multiple displays.
     const DisplayMode* mirror_mode;
   };
 
   typedef std::vector<DisplayState> DisplayStateList;
 
   class Observer {
@@ skipping 32 matching lines @@
   // Interface for classes that implement software based mirroring.
   class SoftwareMirroringController {
    public:
     virtual ~SoftwareMirroringController() {}
 
     // Called when the hardware mirroring failed.
     virtual void SetSoftwareMirroring(bool enabled) = 0;
     virtual bool SoftwareMirroringEnabled() const = 0;
   };
 
-  class TouchscreenDelegate {
-   public:
-    virtual ~TouchscreenDelegate() {}
-
-    // Searches for touchscreens among input devices,
-    // and tries to match them up to screens in |displays|.
-    // |displays| is an array of detected screens.
-    // If a touchscreen with same resolution as a display's native mode
-    // is detected, its id will be stored in this display.
-    virtual void AssociateTouchscreens(std::vector<DisplayState>* displays) = 0;
-  };
-
   // Helper class used by tests.
   class TestApi {
    public:
     TestApi(DisplayConfigurator* configurator) : configurator_(configurator) {}
     ~TestApi() {}
 
     // If |configure_timer_| is started, stops the timer, runs
     // ConfigureDisplays(), and returns true; returns false otherwise.
     bool TriggerConfigureTimeout();
 
@@ skipping 40 matching lines @@
     state_controller_ = controller;
   }
   void set_mirroring_controller(SoftwareMirroringController* controller) {
     mirroring_controller_ = controller;
   }
 
   // Replaces |native_display_delegate_| and |touchscreen_delegate_| with the 2
   // delegates passed in and sets |configure_display_| to true. Should be called
   // before Init().
   void SetDelegatesForTesting(
-      scoped_ptr<NativeDisplayDelegate> display_delegate,
-      scoped_ptr<TouchscreenDelegate> touchscreen_delegate);
+      scoped_ptr<NativeDisplayDelegate> display_delegate);
 
   // Sets the initial value of |power_state_|.  Must be called before Start().
   void SetInitialDisplayPower(chromeos::DisplayPowerState power_state);
 
   // Initialization, must be called right after constructor.
   // |is_panel_fitting_enabled| indicates hardware panel fitting support.
   void Init(bool is_panel_fitting_enabled);
 
   // Does initial configuration of displays during startup.
   // If |background_color_argb| is non zero and there are multiple displays,
@@ skipping 64 matching lines @@
   bool SetColorCalibrationProfile(int64_t display_id,
                                   ui::ColorCalibrationProfile new_profile);
 
  private:
   // Mapping a display_id to a protection request bitmask.
   typedef std::map<int64_t, uint32_t> ContentProtections;
   // Mapping a client to its protection request.
   typedef std::map<ContentProtectionClientId, ContentProtections>
       ProtectionRequests;
 
-  // If |native_display_delegate_| and |touchscreen_delegate_| are not set, then
-  // set them to the passed in values.
+  // If |native_display_delegate_| is not set, then set it to
+  // |display_delegate|.
   void InitializeDelegates(
-      scoped_ptr<NativeDisplayDelegate> display_delegate,
-      scoped_ptr<TouchscreenDelegate> touchscreen_delegate);
+      scoped_ptr<NativeDisplayDelegate> display_delegate);
 
   // Performs platform specific delegate initialization.
   void PlatformInitialize();
 
   // Updates |cached_displays_| to contain currently-connected displays. Calls
   // |delegate_->GetDisplays()| and then does additional work, like finding the
   // mirror mode and setting user-preferred modes. Note that the server must be
   // grabbed via |delegate_->GrabServer()| first.
   void UpdateCachedDisplays();
 
@@ skipping 47 matching lines @@
 
   // Returns true if in either hardware or software mirroring mode.
   bool IsMirroring() const;
 
   // Applies display protections according to requests.
   bool ApplyProtections(const ContentProtections& requests);
 
   StateController* state_controller_;
   SoftwareMirroringController* mirroring_controller_;
   scoped_ptr<NativeDisplayDelegate> native_display_delegate_;
-  scoped_ptr<TouchscreenDelegate> touchscreen_delegate_;
 
   // Used to enable modes which rely on panel fitting.
   bool is_panel_fitting_enabled_;
 
   // This is detected by the constructor to determine whether or not we should
   // be enabled.  If we aren't running on ChromeOS, we can't assume that the
   // Xrandr X11 extension is supported.
   // If this flag is set to false, any attempts to change the display
   // configuration to immediately fail without changing the state.
   bool configure_display_;
@@ skipping 21 matching lines @@
 
   // Display protection requests of each client.
   ProtectionRequests client_protection_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayConfigurator);
 };
 
 }  // namespace ui
 
 #endif  // UI_DISPLAY_CHROMEOS_DISPLAY_CONFIGURATOR_H_