exo: Initial support for multiple displays in ARC

components/exo/shell_surface.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/shell_surface.h"
 
 #include <algorithm>
 
 #include "ash/common/frame/custom_frame_view_ash.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
+#include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
+#include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/exo/surface.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 111 matching lines @@
     }
     return aura::WindowTargeter::FindTargetForEvent(root, event);
   }
 
  private:
   views::Widget* const widget_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomWindowTargeter);
 };
 
+class CustomWindowResizer : public ash::WindowResizer {
+ public:
+  explicit CustomWindowResizer(ash::wm::WindowState* window_state)
+      : WindowResizer(window_state), shell_(GetTarget()->GetShell()) {
+    shell_->LockCursor();
+  }
+

[reveman, 2017/03/02 02:00:38]

nit: remove this blank line

[Dominik Laskowski, 2017/03/03 13:50:40]

Done.

+  ~CustomWindowResizer() override { shell_->UnlockCursor(); }
+
+  // ash::WindowResizer:

[reveman, 2017/03/02 02:00:38]

nit: // Overridden from ash::WindowResizer:

[Dominik Laskowski, 2017/03/03 13:50:40]

Done.

+  void Drag(const gfx::Point& location, int event_flags) override {}
+  void CompleteDrag() override {}
+  void RevertDrag() override {}
+
+ private:
+  ash::WmShell* const shell_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomWindowResizer);
+};
+
 class ShellSurfaceWidget : public views::Widget {
  public:
   explicit ShellSurfaceWidget(ShellSurface* shell_surface)
       : shell_surface_(shell_surface) {}
 
   // Overridden from views::Widget
   void Close() override { shell_surface_->Close(); }
   void OnKeyEvent(ui::KeyEvent* event) override {
     // TODO(hidehiko): Handle ESC + SHIFT + COMMAND accelerator key
     // to escape pinned mode.
@@ skipping 141 matching lines @@
                            int container)
     : widget_(nullptr),
       surface_(surface),
       parent_(parent ? parent->GetWidget()->GetNativeWindow() : nullptr),
       bounds_mode_(bounds_mode),
       origin_(origin),
       activatable_(activatable),
       can_minimize_(can_minimize),
       container_(container) {
   WMHelper::GetInstance()->AddActivationObserver(this);
+  WMHelper::GetInstance()->AddDisplayConfigurationObserver(this);
   surface_->SetSurfaceDelegate(this);
   surface_->AddSurfaceObserver(this);
   surface_->window()->Show();
   set_owned_by_client();
   if (parent_)
     parent_->AddObserver(this);
 }
 
 ShellSurface::ShellSurface(Surface* surface)
     : ShellSurface(surface,
@@ skipping 12 matching lines @@
     ash::wm::GetWindowState(widget_->GetNativeWindow())->RemoveObserver(this);
     widget_->GetNativeWindow()->RemoveObserver(this);
     // Remove transient children so they are not automatically destroyed.
     for (auto child : wm::GetTransientChildren(widget_->GetNativeWindow()))
       wm::RemoveTransientChild(widget_->GetNativeWindow(), child);
     if (widget_->IsVisible())
       widget_->Hide();
     widget_->CloseNow();
   }
   WMHelper::GetInstance()->RemoveActivationObserver(this);
+  WMHelper::GetInstance()->RemoveDisplayConfigurationObserver(this);
   if (parent_)
     parent_->RemoveObserver(this);
   if (surface_) {
     if (scale_ != 1.0)
       surface_->window()->SetTransform(gfx::Transform());
     surface_->SetSurfaceDelegate(nullptr);
     surface_->RemoveSurfaceObserver(this);
   }
   WMHelper::GetInstance()->RemoveAccessibilityObserver(this);
 }
@@ skipping 168 matching lines @@
 void ShellSurface::SetApplicationId(const std::string& application_id) {
   // Store the value in |application_id_| in case the window does not exist yet.
   application_id_ = application_id;
   if (widget_ && widget_->GetNativeWindow())
     SetApplicationId(widget_->GetNativeWindow(), application_id);
 }
 
 void ShellSurface::Move() {
   TRACE_EVENT0("exo", "ShellSurface::Move");
 
-  if (!widget_)
+  if (!widget_ || resizer_)

[reveman, 2017/03/02 02:00:38]

why is this needed now?

[Dominik Laskowski, 2017/03/03 13:50:40]

This check was pulled out from AttemptToStartDrag to be shared with
AttemptToStartClientDrag, but I've merged those in the latest patch.

     return;
 
   switch (bounds_mode_) {
     case BoundsMode::SHELL:
       AttemptToStartDrag(HTCAPTION);
       return;
     case BoundsMode::CLIENT:
+      AttemptToStartClientDrag();

[reveman, 2017/03/02 02:00:38]

nit: please move switch statement into AttemptToStartDrag instead so
AttemptToStartClientDrag is not needed. I'm not a fan of the "ClientDrag" name
in general

[Dominik Laskowski, 2017/03/03 13:50:40]

Merged AttemptToStartClientDrag into AttemptToStartDrag.

+      return;
     case BoundsMode::FIXED:
       return;
   }
 
   NOTREACHED();
 }
 
 void ShellSurface::Resize(int component) {
   TRACE_EVENT1("exo", "ShellSurface::Resize", "component", component);
 
-  if (!widget_)
+  if (!widget_ || resizer_)

[reveman, 2017/03/02 02:00:38]

why is this needed now?

[Dominik Laskowski, 2017/03/03 13:50:40]

See above.

     return;
 
   switch (bounds_mode_) {
     case BoundsMode::SHELL:
       AttemptToStartDrag(component);
       return;
     case BoundsMode::CLIENT:
     case BoundsMode::FIXED:
       return;
   }
@@ skipping 435 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WMHelper::AccessibilityObserver overrides:
 
 void ShellSurface::OnAccessibilityModeChanged() {
   UpdateShadow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// WMHelper::DisplayConfigurationObserver overrides:
+
+void ShellSurface::OnDisplayConfigurationChanged() {
+  if (!display_config_changed_callback_.is_null())
+    display_config_changed_callback_.Run();

[reveman, 2017/03/02 02:00:38]

why not send a configure request and adjust origin here directly for
BoundsMode::CLIENT? I thought the purpose of bounds_mode_ was so we could do
that.

[Dominik Laskowski, 2017/03/03 13:50:40]

Given that the origin is part of the public ShellSurface API (constructor and
SetOrigin), I think it's cleaner for the origin to be computed by the user of
ShellSurface, i.e. WaylandRemoteShell.

[reveman, 2017/03/06 19:02:13]

As other changes to origin happen internally and result in configure events I
much prefer if that was also the case for display configuration changes. If this
means we can remove SetOrigin API then that would be great but maybe we still
need that..

[Dominik Laskowski, 2017/03/08 23:13:22]

But then ShellSurface would contain logic specific to Android. With this
injection, the virtual display concept is at least contained in
WaylandRemoteShell.

+}
+
+////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void ShellSurface::OnKeyEvent(ui::KeyEvent* event) {
   if (!resizer_) {
     views::View::OnKeyEvent(event);
     return;
   }
 
-  if (event->type() == ui::ET_KEY_PRESSED &&
+  if (bounds_mode_ == BoundsMode::SHELL &&

[reveman, 2017/03/02 02:00:38]

We should be allowed to cancel a client drag too. Why add this special case?

[Dominik Laskowski, 2017/03/03 13:50:40]

We need to sync window states to revert dragging properly in the CLIENT case. I
figured that we should disable this until then (even though it's not an issue
because the client currently destroys the window on VKEY_ESCAPE).

[reveman, 2017/03/06 19:02:13]

Please leave this the way it's supposed to work long term of that's not causing
problems. Temporary code that is doing something else on the Chrome side should
at a minimal have a TODO statement with description and a bug number to make it
clear that the code is should updated when possible.

[Dominik Laskowski, 2017/03/08 23:13:22]

Reverted and added TODO.

+      event->type() == ui::ET_KEY_PRESSED &&
       event->key_code() == ui::VKEY_ESCAPE) {
     EndDrag(true /* revert */);
   }
 }
 
 void ShellSurface::OnMouseEvent(ui::MouseEvent* event) {
   if (!resizer_) {
     views::View::OnMouseEvent(event);
     return;
   }
 
   if (event->handled())
     return;
 
   if ((event->flags() &
        (ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON)) != 0)
     return;
 
   if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED) {
     // We complete the drag instead of reverting it, as reverting it will
     // result in a weird behavior when a client produces a modal dialog
     // while the drag is in progress.
     EndDrag(false /* revert */);
     return;
   }
 
   switch (event->type()) {
     case ui::ET_MOUSE_DRAGGED: {
+      if (bounds_mode_ == BoundsMode::CLIENT)
+        break;
+
       gfx::Point location(event->location());
       aura::Window::ConvertPointToTarget(widget_->GetNativeWindow(),
                                          widget_->GetNativeWindow()->parent(),
                                          &location);
       ScopedConfigure scoped_configure(this, false);
       resizer_->Drag(location, event->flags());
       event->StopPropagation();
       break;
     }
     case ui::ET_MOUSE_RELEASED: {
@@ skipping 158 matching lines @@
   // configure request has been acknowledged.
   pending_configs_.push_back({serial, origin_offset, resize_component});
   LOG_IF(WARNING, pending_configs_.size() > 100)
       << "Number of pending configure acks for shell surface has reached: "
       << pending_configs_.size();
 }
 
 void ShellSurface::AttemptToStartDrag(int component) {
   DCHECK(widget_);
 
-  // Cannot start another drag if one is already taking place.

[reveman, 2017/03/02 02:00:38]

why remove this?

[Dominik Laskowski, 2017/03/03 13:50:40]

See above.

-  if (resizer_)
-    return;
-
   if (widget_->GetNativeWindow()->HasCapture())
     return;
 
-  aura::Window* root_window = widget_->GetNativeWindow()->GetRootWindow();
-  gfx::Point drag_location =
-      root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
-  aura::Window::ConvertPointToTarget(
-      root_window, widget_->GetNativeWindow()->parent(), &drag_location);
-
   // Set the cursor before calling CreateWindowResizer(), as that will
   // eventually call LockCursor() and prevent the cursor from changing.
-  aura::client::CursorClient* cursor_client =
-      aura::client::GetCursorClient(root_window);
+  aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(
+      widget_->GetNativeWindow()->GetRootWindow());
   DCHECK(cursor_client);
 
   switch (component) {
     case HTCAPTION:
       cursor_client->SetCursor(ui::kCursorPointer);
       break;
     case HTTOP:
       cursor_client->SetCursor(ui::kCursorNorthResize);
       break;
     case HTTOPRIGHT:
@@ skipping 16 matching lines @@
       break;
     case HTTOPLEFT:
       cursor_client->SetCursor(ui::kCursorNorthWestResize);
       break;
     default:
       NOTREACHED();
       break;
   }
 
   resizer_ = ash::CreateWindowResizer(
-      ash::WmWindow::Get(widget_->GetNativeWindow()), drag_location, component,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+      ash::WmWindow::Get(widget_->GetNativeWindow()), GetMouseLocation(),
+      component, aura::client::WINDOW_MOVE_SOURCE_MOUSE);
   if (!resizer_)
     return;
 
   // Apply pending origin offsets and resize direction before starting a new
   // resize operation. These can still be pending if the client has acknowledged
   // the configure request but not yet called Commit().
   origin_offset_ += pending_origin_offset_;
   pending_origin_offset_ = gfx::Vector2d();
   resize_component_ = pending_resize_component_;
 
   WMHelper::GetInstance()->AddPreTargetHandler(this);
   widget_->GetNativeWindow()->SetCapture();
 
   // Notify client that resizing state has changed.
   if (IsResizing())
     Configure();
 }
 
+void ShellSurface::AttemptToStartClientDrag() {
+  DCHECK(widget_);
+
+  if (surface_->window()->HasCapture())
+    return;
+
+  ash::wm::WindowState* const window_state =
+      ash::wm::GetWindowState(widget_->GetNativeWindow());
+
+  DCHECK(!window_state->drag_details());
+  window_state->CreateDragDetails(GetMouseLocation(), HTCAPTION,
+                                  aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+
+  // The resizer renders phantom windows, but does not control window movement.
+  resizer_.reset(ash::DragWindowResizer::Create(
+      new CustomWindowResizer(window_state), window_state));
+
+  WMHelper::GetInstance()->AddPreTargetHandler(this);
+  surface_->window()->SetCapture();
+}
+
 void ShellSurface::EndDrag(bool revert) {
   DCHECK(widget_);
   DCHECK(resizer_);
 
-  bool was_resizing = IsResizing();
+  switch (bounds_mode_) {
+    case BoundsMode::SHELL: {
+      bool was_resizing = IsResizing();
 
+      EndDrag(widget_->GetNativeWindow(), revert);
+
+      // Notify client that resizing state has changed.
+      if (was_resizing)
+        Configure();
+
+      UpdateWidgetBounds();
+      return;
+    }
+    case BoundsMode::CLIENT:
+      EndDrag(surface_->window(), revert);

[reveman, 2017/03/02 02:00:38]

why are we using surface_->window() here instead of widget_->GetNativeWindow()?
what if surface_ is gone?

[Dominik Laskowski, 2017/03/03 13:50:40]

The surface window needs to have capture, because it's the target for mouse
events that get forwarded to the client. Good point, I've added a null check in
AttemptToStartDrag and a DCHECK here as a precaution against a bad client that
sends a "move" request after the surface is destroyed.

[reveman, 2017/03/06 19:02:13]

The general idea of doing a capture on the surface window to have events still
sent to the client seems like a bit of a hack and doesn't work with MUS support
as only the top-level ShellSurface will have a window in the future. I think it
would be best to have these changes to movement sent back to the client as
origin changes in configure events. This would also allow features like window
snapping to work properly.

I'm OK saving this as a follow up but please file bugs and add appropriate
TODO's where needed in the code. 

[Dominik Laskowski, 2017/03/08 23:13:22]

Filed crbug.com/699746 and added TODOs.

+      return;
+    case BoundsMode::FIXED:
+      break;
+  }
+
+  NOTREACHED();
+}
+
+void ShellSurface::EndDrag(aura::Window* window, bool revert) {
   if (revert)
     resizer_->RevertDrag();
   else
     resizer_->CompleteDrag();
 
   WMHelper::GetInstance()->RemovePreTargetHandler(this);
-  widget_->GetNativeWindow()->ReleaseCapture();
+  window->ReleaseCapture();
   resizer_.reset();
-

[reveman, 2017/03/02 02:00:38]

why not keep this the way it is?

[Dominik Laskowski, 2017/03/03 13:50:40]

Refactored to be consistent with AttemptToStartDrag.

-  // Notify client that resizing state has changed.
-  if (was_resizing)
-    Configure();
-
-  UpdateWidgetBounds();
 }
 
 bool ShellSurface::IsResizing() const {
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(widget_->GetNativeWindow());
   if (!window_state->is_dragged())
     return false;
 
   return window_state->drag_details()->bounds_change &
          ash::WindowResizer::kBoundsChange_Resizes;
@@ skipping 85 matching lines @@
         new_widget_bounds.set_origin(
             widget_->GetWindowBoundsInScreen().origin());
       }
       break;
   }
 
   // Set |ignore_window_bounds_changes_| as this change to window bounds
   // should not result in a configure request.
   DCHECK(!ignore_window_bounds_changes_);
   ignore_window_bounds_changes_ = true;
-  if (widget_->GetWindowBoundsInScreen() != new_widget_bounds)
-    widget_->SetBounds(new_widget_bounds);
+  const gfx::Rect widget_bounds = widget_->GetWindowBoundsInScreen();
+  if (widget_bounds != new_widget_bounds) {
+    if (bounds_mode_ != BoundsMode::CLIENT || !resizer_) {
+      widget_->SetBounds(new_widget_bounds);
+      UpdateSurfaceBounds();
+    } else {
+      // TODO(domlaskowski): Synchronize window state transitions with the
+      // client, and abort client-side dragging on transition to fullscreen.
+      LOG_IF(ERROR, widget_bounds.size() != new_widget_bounds.size())
+          << "Window size changed during client-driven drag";
+
+      // Convert from screen to display coordinates.
+      gfx::Point origin = new_widget_bounds.origin();
+      wm::ConvertPointFromScreen(widget_->GetNativeWindow()->parent(), &origin);
+      new_widget_bounds.set_origin(origin);
+
+      // Move the window relative to the current display.
+      widget_->GetNativeWindow()->SetBounds(new_widget_bounds);
+      UpdateSurfaceBounds();
+
+      // Render phantom windows when beyond the current display.
+      resizer_->Drag(GetMouseLocation(), 0);
+    }
+  }
+
   ignore_window_bounds_changes_ = false;
 }
 
 void ShellSurface::UpdateSurfaceBounds() {
   gfx::Rect client_view_bounds =
       widget_->non_client_view()->frame_view()->GetBoundsForClientView();
 
   surface_->window()->SetBounds(
       gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
                 surface_->window()->layer()->size()));
@@ skipping 143 matching lines @@
     // Surfaces that can't be activated are usually menus and tooltips. Use a
     // small style shadow for them.
     if (!activatable_)
       shadow->SetElevation(wm::ShadowElevation::SMALL);
     // We don't have rounded corners unless frame is enabled.
     if (!frame_enabled_)
       shadow->SetRoundedCornerRadius(0);
   }
 }
 
+gfx::Point ShellSurface::GetMouseLocation() const {
+  aura::Window* const root_window = widget_->GetNativeWindow()->GetRootWindow();
+  gfx::Point location =
+      root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
+  aura::Window::ConvertPointToTarget(
+      root_window, widget_->GetNativeWindow()->parent(), &location);
+  return location;
+}
+
 }  // namespace exo