exo: Reparent pointer surface

components/exo/pointer.cc

 // Copyright 2015 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 "components/exo/pointer.h"
 
 #include <utility>
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 60 matching lines @@
 // Pointer, public:
 
 Pointer::Pointer(PointerDelegate* delegate)
     : delegate_(delegate),
       cursor_(ui::CursorType::kNull),
       cursor_capture_source_id_(base::UnguessableToken::Create()),
       cursor_capture_weak_ptr_factory_(this) {
   auto* helper = WMHelper::GetInstance();
   helper->AddPreTargetHandler(this);
   helper->AddCursorObserver(this);
+  helper->AddDisplayConfigurationObserver(this);
 }
 
 Pointer::~Pointer() {
   delegate_->OnPointerDestroying(this);
   if (surface_)
     surface_->RemoveSurfaceObserver(this);
   if (focus_) {
     focus_->RemoveSurfaceObserver(this);
     focus_->UnregisterCursorProvider(this);
   }
   auto* helper = WMHelper::GetInstance();
+  helper->RemoveDisplayConfigurationObserver(this);
   helper->RemoveCursorObserver(this);
   helper->RemovePreTargetHandler(this);
 }
 
 void Pointer::SetCursor(Surface* surface, const gfx::Point& hotspot) {
   // Early out if the pointer doesn't have a surface in focus.
   if (!focus_)
     return;
 
   // This is used to avoid unnecessary cursor changes.
   bool cursor_changed = false;
 
   // If surface is different than the current pointer surface then remove the
   // current surface and add the new surface.
   if (surface != surface_) {
     if (surface && surface->HasSurfaceDelegate()) {
       DLOG(ERROR) << "Surface has already been assigned a role";
       return;
     }
-    if (surface_) {
-      surface_->window()->SetTransform(gfx::Transform());
-      if (surface_->window()->parent())
-        surface_->window()->parent()->RemoveChild(surface_->window());
-      surface_->SetSurfaceDelegate(nullptr);
-      surface_->RemoveSurfaceObserver(this);
-    }
-    surface_ = surface;
-    if (surface_) {
-      surface_->SetSurfaceDelegate(this);
-      surface_->AddSurfaceObserver(this);
-      // Note: Surface window needs to be added to the tree so we can take a
-      // snapshot. Where in the tree is not important but we might as well use
-      // the cursor container.
-      WMHelper::GetInstance()
-          ->GetPrimaryDisplayContainer(ash::kShellWindowId_MouseCursorContainer)
-          ->AddChild(surface_->window());
-    }
+    UpdatePointerSurface(surface);
     cursor_changed = true;
   }
 
   if (hotspot != hotspot_)
     cursor_changed = true;
 
   // Early out if cursor did not change.
   if (!cursor_changed) {
     // Cursor scale or rotation may have changed.
     UpdateCursor();
@@ skipping 135 matching lines @@
   if (focus_)
     UpdateCursor();
 }
 
 void Pointer::OnCursorDisplayChanged(const display::Display& display) {
   if (focus_)
     UpdateCursor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// WMHelper::DisplayConfigurationObserver overrides:
+
+void Pointer::OnDisplayConfigurationChanged() {
+  UpdatePointerSurface(surface_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // SurfaceDelegate overrides:
 
 void Pointer::OnSurfaceCommit() {
   surface_->CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
   surface_->CommitSurfaceHierarchy();
 
   // Capture new cursor to reflect result of commit.
   if (focus_)
     CaptureCursor(hotspot_);
 }
@@ skipping 20 matching lines @@
 
 Surface* Pointer::GetEffectiveTargetForEvent(ui::Event* event) const {
   Surface* target =
       Surface::AsSurface(static_cast<aura::Window*>(event->target()));
   if (!target)
     return nullptr;
 
   return delegate_->CanAcceptPointerEventsForSurface(target) ? target : nullptr;
 }
 
+void Pointer::UpdatePointerSurface(Surface* surface) {
+  if (surface_) {
+    surface_->window()->SetTransform(gfx::Transform());
+    if (surface_->window()->parent())
+      surface_->window()->parent()->RemoveChild(surface_->window());
+    surface_->SetSurfaceDelegate(nullptr);
+    surface_->RemoveSurfaceObserver(this);
+  }
+  surface_ = surface;
+  if (surface_) {
+    surface_->SetSurfaceDelegate(this);
+    surface_->AddSurfaceObserver(this);
+    // Note: Surface window needs to be added to the tree so we can take a
+    // snapshot. Where in the tree is not important but we might as well use
+    // the cursor container.
+    WMHelper::GetInstance()
+        ->GetPrimaryDisplayContainer(ash::kShellWindowId_MouseCursorContainer)
+        ->AddChild(surface_->window());
+  }
+}
+
 void Pointer::CaptureCursor(const gfx::Point& hotspot) {
   DCHECK(surface_);
   DCHECK(focus_);
 
   // Surface size is in DIPs, while layer size is in pseudo-DIP units that
   // depend on the DSF of the display mode. Scale the layer to capture the
   // surface at a constant pixel size, regardless of the primary display's
   // UI scale and display mode DSF.
   display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   auto* helper = WMHelper::GetInstance();
@@ skipping 70 matching lines @@
   if (!root_window)
     return;
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window);
   if (cursor_client)
     cursor_client->SetCursor(cursor_);
 }
 
 }  // namespace exo