Moving input device hotplug event processing outside of ui/display

ui/display/chromeos/display_configurator.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 "ui/display/chromeos/display_configurator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
-#include "ui/display/chromeos/touchscreen_delegate_impl.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/types/chromeos/display_mode.h"
 #include "ui/display/types/chromeos/display_snapshot.h"
 #include "ui/display/types/chromeos/native_display_delegate.h"
 
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
@@ skipping 72 matching lines @@
 }  // namespace
 
 
 const int DisplayConfigurator::kSetDisplayPowerNoFlags = 0;
 const int DisplayConfigurator::kSetDisplayPowerForceProbe = 1 << 0;
 const int
 DisplayConfigurator::kSetDisplayPowerOnlyIfSingleInternalDisplay = 1 << 1;
 
 DisplayConfigurator::DisplayState::DisplayState()
     : display(NULL),
-      touch_device_id(0),
       selected_mode(NULL),
       mirror_mode(NULL) {}
 
 bool DisplayConfigurator::TestApi::TriggerConfigureTimeout() {
   if (configurator_->configure_timer_.IsRunning()) {
     configurator_->configure_timer_.user_task().Run();
     configurator_->configure_timer_.Stop();
     return true;
   } else {
     return false;
@@ skipping 45 matching lines @@
       configure_display_(base::SysInfo::IsRunningOnChromeOS()),
       display_state_(MULTIPLE_DISPLAY_STATE_INVALID),
       power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       next_display_protection_client_id_(1) {}
 
 DisplayConfigurator::~DisplayConfigurator() {
   if (native_display_delegate_)
     native_display_delegate_->RemoveObserver(this);
 }
 
-void DisplayConfigurator::SetDelegatesForTesting(
-    scoped_ptr<NativeDisplayDelegate> display_delegate,
-    scoped_ptr<TouchscreenDelegate> touchscreen_delegate) {
+void DisplayConfigurator::SetDelegateForTesting(
+    scoped_ptr<NativeDisplayDelegate> display_delegate) {
   DCHECK(!native_display_delegate_);
-  DCHECK(!touchscreen_delegate_);
 
   native_display_delegate_ = display_delegate.Pass();
-  touchscreen_delegate_ = touchscreen_delegate.Pass();
   configure_display_ = true;
 }
 
 void DisplayConfigurator::SetInitialDisplayPower(
     chromeos::DisplayPowerState power_state) {
   DCHECK_EQ(display_state_, MULTIPLE_DISPLAY_STATE_INVALID);
   power_state_ = power_state;
 }
 
 void DisplayConfigurator::Init(bool is_panel_fitting_enabled) {
   is_panel_fitting_enabled_ = is_panel_fitting_enabled;
   if (!configure_display_)
     return;
 
-  // If the delegates are already initialized don't update them (For example,
-  // tests set their own delegates).
+  // If the delegate is already initialized don't update it (For example, tests
+  // set their own delegates).
   if (!native_display_delegate_) {
     native_display_delegate_ = CreatePlatformNativeDisplayDelegate();
     native_display_delegate_->AddObserver(this);
   }
-
-  if (!touchscreen_delegate_)
-    touchscreen_delegate_.reset(new TouchscreenDelegateImpl());
 }
 
 void DisplayConfigurator::ForceInitialConfigure(
     uint32_t background_color_argb) {
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   native_display_delegate_->Initialize();
 
@@ skipping 353 matching lines @@
   std::vector<DisplaySnapshot*> snapshots =
       native_display_delegate_->GetDisplays();
 
   cached_displays_.clear();
   for (size_t i = 0; i < snapshots.size(); ++i) {
     DisplayState display_state;
     display_state.display = snapshots[i];
     cached_displays_.push_back(display_state);
   }
 
-  touchscreen_delegate_->AssociateTouchscreens(&cached_displays_);
-
   // Set |selected_mode| fields.
   for (size_t i = 0; i < cached_displays_.size(); ++i) {
     DisplayState* display_state = &cached_displays_[i];
     if (display_state->display->has_proper_display_id()) {
       gfx::Size size;
       if (state_controller_ &&
           state_controller_->GetResolutionForDisplayId(
               display_state->display->display_id(), &size)) {
         display_state->selected_mode =
             FindDisplayModeMatchingSize(*display_state->display, size);
@@ skipping 370 matching lines @@
         return state_controller_->GetStateForDisplayIds(display_ids);
       }
     }
     default:
       NOTREACHED();
   }
   return MULTIPLE_DISPLAY_STATE_INVALID;
 }
 
 }  // namespace ui