Fix software mirror mode on Ozone part 2/2

ash/touch/touch_transformer_controller.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 "ash/touch/touch_transformer_controller.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/display/chromeos/display_configurator.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/events/devices/device_data_manager.h"
 
 namespace ash {
 
 namespace {
 
-DisplayManager* GetDisplayManager() {
-  return Shell::GetInstance()->display_manager();
-}
-
 ui::TouchscreenDevice FindTouchscreenById(unsigned int id) {
   const std::vector<ui::TouchscreenDevice>& touchscreens =
       ui::DeviceDataManager::GetInstance()->touchscreen_devices();
   for (const auto& touchscreen : touchscreens) {
     if (touchscreen.id == id)
       return touchscreen;
   }
 
   return ui::TouchscreenDevice();
 }
@@ skipping 84 matching lines @@
 TouchTransformerController::TouchTransformerController() {
   Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 TouchTransformerController::~TouchTransformerController() {
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
 void TouchTransformerController::UpdateTouchTransformer() const {
   ui::DeviceDataManager* device_manager = ui::DeviceDataManager::GetInstance();
-  device_manager->ClearTouchTransformerRecord();
+  device_manager->ClearTouchDeviceAssociations();
 
   // Display IDs and DisplayInfo for mirror or extended mode.
   int64 display1_id = gfx::Display::kInvalidDisplayID;
   int64 display2_id = gfx::Display::kInvalidDisplayID;
   DisplayInfo display1;
   DisplayInfo display2;
   // Display ID and DisplayInfo for single display mode.
   int64 single_display_id = gfx::Display::kInvalidDisplayID;
   DisplayInfo single_display;
 
   DisplayController* display_controller =
       Shell::GetInstance()->display_controller();
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+
   ui::MultipleDisplayState display_state =
       Shell::GetInstance()->display_configurator()->display_state();
   if (display_state == ui::MULTIPLE_DISPLAY_STATE_INVALID ||
       display_state == ui::MULTIPLE_DISPLAY_STATE_HEADLESS) {
     return;
   } else if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR ||
              display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {
-    DisplayIdPair id_pair = GetDisplayManager()->GetCurrentDisplayIdPair();
+    DisplayIdPair id_pair = display_manager->GetCurrentDisplayIdPair();
     display1_id = id_pair.first;
     display2_id = id_pair.second;
     DCHECK(display1_id != gfx::Display::kInvalidDisplayID &&
            display2_id != gfx::Display::kInvalidDisplayID);
-    display1 = GetDisplayManager()->GetDisplayInfo(display1_id);
-    display2 = GetDisplayManager()->GetDisplayInfo(display2_id);
+    display1 = display_manager->GetDisplayInfo(display1_id);
+    display2 = display_manager->GetDisplayInfo(display2_id);
     device_manager->UpdateTouchRadiusScale(
         display1.touch_device_id(),
         GetTouchResolutionScale(
             display1,
             FindTouchscreenById(display1.touch_device_id())));
     device_manager->UpdateTouchRadiusScale(
         display2.touch_device_id(),
         GetTouchResolutionScale(
             display2,
             FindTouchscreenById(display2.touch_device_id())));
   } else {
-    single_display_id = GetDisplayManager()->first_display_id();
+    single_display_id = display_manager->first_display_id();
     DCHECK(single_display_id != gfx::Display::kInvalidDisplayID);
-    single_display = GetDisplayManager()->GetDisplayInfo(single_display_id);
+    single_display = display_manager->GetDisplayInfo(single_display_id);
     device_manager->UpdateTouchRadiusScale(
         single_display.touch_device_id(),
         GetTouchResolutionScale(
             single_display,
             FindTouchscreenById(single_display.touch_device_id())));
   }
 
   gfx::Size fb_size =
       Shell::GetInstance()->display_configurator()->framebuffer_size();
 
   if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR) {
-    // In mirror mode, both displays share the same root window so
-    // both display ids are associated with the root window.
-    aura::Window* root = display_controller->GetPrimaryRootWindow();
-    RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
-        display1_id, display2_id);
+    // In mirror mode, there is just one WindowTreeHost and two displays. Make
+    // the WindowTreeHost accept touch events from both displays.
     device_manager->UpdateTouchInfoForDisplay(
-        display1_id, display1.touch_device_id(),
+        display_manager->GetDisplayForId(display1_id),
+        display1.touch_device_id(),
         GetTouchTransform(display1, display1,
                           FindTouchscreenById(display1.touch_device_id()),
                           fb_size));
     device_manager->UpdateTouchInfoForDisplay(
-        display2_id, display2.touch_device_id(),
+        display_manager->GetDisplayForId(display2_id),
+        display2.touch_device_id(),
         GetTouchTransform(display2, display2,
                           FindTouchscreenById(display2.touch_device_id()),
                           fb_size));
     return;
   }
 
   if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {
-    // In extended but software mirroring mode, ther is only one X root window
-    // that associates with both displays.
-    if (GetDisplayManager()->software_mirroring_enabled())  {
-      aura::Window* root = display_controller->GetPrimaryRootWindow();
-      RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
-          display1_id, display2_id);
+    // In extended but software mirroring mode, there is a WindowTreeHost for
+    // each display, but all touches are forwarded to the primary root window's
+    // WindowTreeHost.
+    if (display_manager->software_mirroring_enabled())  {
       DisplayInfo source_display =
           display_controller->GetPrimaryDisplayId() == display1_id ? display1
                                                                    : display2;
       // Mapping from framebuffer size to the source display's native
       // resolution.
       device_manager->UpdateTouchInfoForDisplay(
-          display1_id, display1.touch_device_id(),
+          display_manager->GetDisplayForId(display1_id),
+          display1.touch_device_id(),
           GetTouchTransform(source_display, display1,
                             FindTouchscreenById(display1.touch_device_id()),
                             fb_size));
       device_manager->UpdateTouchInfoForDisplay(
-          display2_id, display2.touch_device_id(),
+          display_manager->GetDisplayForId(display2_id),
+          display2.touch_device_id(),
           GetTouchTransform(source_display, display2,
                             FindTouchscreenById(display2.touch_device_id()),
                             fb_size));
     } else {
-      // In actual extended mode, each display is associated with one root
-      // window.
-      aura::Window* root1 =
-          display_controller->GetRootWindowForDisplayId(display1_id);
-      aura::Window* root2 =
-          display_controller->GetRootWindowForDisplayId(display2_id);
-      RootWindowController::ForWindow(root1)->ash_host()->UpdateDisplayID(
-          display1_id, gfx::Display::kInvalidDisplayID);
-      RootWindowController::ForWindow(root2)->ash_host()->UpdateDisplayID(
-          display2_id, gfx::Display::kInvalidDisplayID);
+      // In actual extended mode, each display is associated with one
+      // WindowTreeHost.
       // Mapping from framebuffer size to each display's native resolution.
       device_manager->UpdateTouchInfoForDisplay(
-          display1_id, display1.touch_device_id(),
+          display_manager->GetDisplayForId(display1_id),
+          display1.touch_device_id(),
           GetTouchTransform(display1, display1,
                             FindTouchscreenById(display1.touch_device_id()),
                             fb_size));
       device_manager->UpdateTouchInfoForDisplay(
-          display2_id, display2.touch_device_id(),
+          display_manager->GetDisplayForId(display2_id),
+          display2.touch_device_id(),
           GetTouchTransform(display2, display2,
                             FindTouchscreenById(display2.touch_device_id()),
                             fb_size));
     }
     return;
   }
 
-  // Single display mode. The root window has one associated display id.
-  aura::Window* root =
-      display_controller->GetRootWindowForDisplayId(single_display.id());
-  RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
-      single_display.id(), gfx::Display::kInvalidDisplayID);
+  // Single display mode. The WindowTreeHost has one associated display id.
   device_manager->UpdateTouchInfoForDisplay(
-      single_display_id, single_display.touch_device_id(),
+      display_manager->GetDisplayForId(single_display_id),
+      single_display.touch_device_id(),
       GetTouchTransform(single_display, single_display,
                         FindTouchscreenById(single_display.touch_device_id()),
                         fb_size));
 }
 
 void TouchTransformerController::OnDisplaysInitialized() {
   UpdateTouchTransformer();
 }
 
 void TouchTransformerController::OnDisplayConfigurationChanged() {
   UpdateTouchTransformer();
 }
 
 }  // namespace ash