exo: Initial support for multiple displays in ARC

components/exo/shell_surface.h

 // 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.
 
 #ifndef COMPONENTS_EXO_SHELL_SURFACE_H_
 #define COMPONENTS_EXO_SHELL_SURFACE_H_
 
+#include <cstdint>
 #include <deque>
 #include <memory>
 #include <string>
 
 #include "ash/common/wm/window_state_observer.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "components/exo/surface_delegate.h"
 #include "components/exo/surface_observer.h"
 #include "components/exo/wm_helper.h"
@@ skipping 20 matching lines @@
 // This class provides functions for treating a surfaces like toplevel,
 // fullscreen or popup widgets, move, resize or maximize them, associate
 // metadata like title and class, etc.
 class ShellSurface : public SurfaceDelegate,
                      public SurfaceObserver,
                      public views::WidgetDelegate,
                      public views::View,
                      public ash::wm::WindowStateObserver,
                      public aura::WindowObserver,
                      public WMHelper::ActivationObserver,
-                     public WMHelper::AccessibilityObserver {
+                     public WMHelper::AccessibilityObserver,
+                     public WMHelper::DisplayConfigurationObserver {
  public:
   enum class BoundsMode { SHELL, CLIENT, FIXED };
 
   // The |origin| is in screen coordinates. When bounds are controlled by the
   // shell or fixed, it determines the initial position of the shell surface.
   // In that case, the position specified as part of the geometry is relative
   // to the shell surface.
   //
   // When bounds are controlled by the client, it represents the origin of a
   // coordinate system to which the position of the shell surface, specified
@@ skipping 32 matching lines @@
 
   // Set the callback to run when the client is asked to configure the surface.
   // The size is a hint, in the sense that the client is free to ignore it if
   // it doesn't resize, pick a smaller size (to satisfy aspect ratio or resize
   // in steps of NxM pixels).
   using ConfigureCallback =
       base::Callback<uint32_t(const gfx::Size& size,
                               ash::wm::WindowStateType state_type,
                               bool resizing,
                               bool activated,
-                              const gfx::Point& origin)>;
+                              const gfx::Vector2d& origin_offset)>;
   void set_configure_callback(const ConfigureCallback& configure_callback) {
     configure_callback_ = configure_callback;
   }
 
   // When the client is asked to configure the surface, it should acknowledge
   // the configure request sometime before the commit. |serial| is the serial
   // from the configure callback.
   void AcknowledgeConfigure(uint32_t serial);
 
   // Set the "parent" of this surface. This window should be stacked above a
@@ skipping 131 matching lines @@
   void OnWindowDestroying(aura::Window* window) override;
 
   // Overridden from WMHelper::ActivationObserver:
   void OnWindowActivated(
       aura::Window* gained_active,
       aura::Window* lost_active) override;
 
   // Overridden from WMHelper::AccessibilityObserver:
   void OnAccessibilityModeChanged() override;
 
+  // Overridden from WMHelper::DisplayConfigurationObserver:
+  void OnDisplayConfigurationChanged() override;
+
   // Overridden from ui::EventHandler:
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnMouseEvent(ui::MouseEvent* event) override;
 
   // Overridden from ui::AcceleratorTarget:
   bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
 
   aura::Window* shadow_overlay() { return shadow_overlay_; }
   aura::Window* shadow_underlay() { return shadow_underlay_; }
 
@@ skipping 10 matching lines @@
     int resize_component;
   };
 
   // Creates the |widget_| for |surface_|. |show_state| is the initial state
   // of the widget (e.g. maximized).
   void CreateShellSurfaceWidget(ui::WindowShowState show_state);
 
   // Asks the client to configure its surface.
   void Configure();
 
+  // Returns the window that has capture during dragging.
+  aura::Window* GetDragWindow() const;
+
   // Attempt to start a drag operation. The type of drag operation to start is
   // determined by |component|.
   void AttemptToStartDrag(int component);
 
   // End current drag operation.
   void EndDrag(bool revert);
 
   // Returns true if surface is currently being resized.
   bool IsResizing() const;
 
@@ skipping 10 matching lines @@
   // Updates the bounds of surface to match the current widget bounds.
   void UpdateSurfaceBounds();
 
   // Creates, deletes and update the shadow bounds based on
   // |pending_shadow_content_bounds_|.
   void UpdateShadow();
 
   // Applies |system_modal_| to |widget_|.
   void UpdateSystemModal();
 
+  // In the coordinate system of the parent root window.
+  gfx::Point GetMouseLocation() const;
+
   views::Widget* widget_ = nullptr;
   Surface* surface_;
   aura::Window* parent_;
   const BoundsMode bounds_mode_;
+  int64_t primary_display_id_;
   gfx::Point origin_;
   bool activatable_ = true;
   const bool can_minimize_;
   // Container Window Id (see ash/public/cpp/shell_window_ids.h)
   int container_;
   bool frame_enabled_ = false;
   bool shadow_enabled_ = false;
   bool pending_show_widget_ = false;
   base::string16 title_;
   std::string application_id_;
@@ skipping 24 matching lines @@
   int pending_top_inset_height_ = 0;
   bool shadow_underlay_in_surface_ = true;
   bool system_modal_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(ShellSurface);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_SHELL_SURFACE_H_