Wires up WmWindowMus::SetBoundsInScreen()

ash/common/wm_window.h

 // Copyright 2016 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 ASH_COMMON_WM_WINDOW_H_
 #define ASH_COMMON_WM_WINDOW_H_
 
 #include <memory>
 #include <vector>
 
@@ skipping 137 matching lines @@
   virtual WmWindow* GetToplevelWindow() = 0;
   // The implementation of this matches
   // aura::client::ActivationClient::GetToplevelWindow().
   virtual WmWindow* GetToplevelWindowForFocus() = 0;
 
   // See aura::client::ParentWindowWithContext() for details of what this does.
   virtual void SetParentUsingContext(WmWindow* context,
                                      const gfx::Rect& screen_bounds) = 0;
   virtual void AddChild(WmWindow* window) = 0;
 
-  virtual WmWindow* GetParent() = 0;
+  WmWindow* GetParent() {
+    return const_cast<WmWindow*>(
+        const_cast<const WmWindow*>(this)->GetParent());
+  }
+  virtual const WmWindow* GetParent() const = 0;
 
   WmWindow* GetTransientParent() {
     return const_cast<WmWindow*>(
         const_cast<const WmWindow*>(this)->GetTransientParent());
   }
   virtual const WmWindow* GetTransientParent() const = 0;
   virtual Windows GetTransientChildren() = 0;
 
   virtual void SetLayoutManager(
       std::unique_ptr<WmLayoutManager> layout_manager) = 0;
@@ skipping 24 matching lines @@
   virtual void SetBoundsDirectCrossFade(const gfx::Rect& bounds) = 0;
 
   // Sets the bounds in two distinct ways. The exact behavior is dictated by
   // the value of BoundsInScreenBehavior set on the parent:
   //
   // USE_LOCAL_COORDINATES: the bounds are applied as is to the window. In other
   //   words this behaves the same as if SetBounds(bounds_in_screen) was used.
   //   This is the default.
   // USE_SCREEN_COORDINATES: the bounds are actual screen bounds and converted
   //   from the display. In this case the window may move to a different
-  //   display if allowed (see SetDescendantsStayInSameRootWindow()).
+  //   display if allowed (see SetLockedToRoot()).

[James Cook, 2016/09/15 16:31:40]

Thanks for collapsing these two.

[sky, 2016/09/15 17:35:03]

It was my mistake for introducing the two in the first place!

   virtual void SetBoundsInScreen(const gfx::Rect& bounds_in_screen,
                                  const display::Display& dst_display) = 0;
   virtual gfx::Rect GetBoundsInScreen() const = 0;
   virtual const gfx::Rect& GetBounds() const = 0;
   virtual gfx::Rect GetTargetBounds() = 0;
 
   virtual void ClearRestoreBounds() = 0;
   virtual void SetRestoreBoundsInScreen(const gfx::Rect& bounds) = 0;
   virtual gfx::Rect GetRestoreBoundsInScreen() const = 0;
 
   virtual bool Contains(const WmWindow* other) const = 0;
 
   virtual void SetShowState(ui::WindowShowState show_state) = 0;
   virtual ui::WindowShowState GetShowState() const = 0;
 
   virtual void SetRestoreShowState(ui::WindowShowState show_state) = 0;
 
   // Sets the restore bounds and show state overrides. These values take
   // precedence over the restore bounds and restore show state (if set).
   // If |bounds_override| is empty the values are cleared.
   virtual void SetRestoreOverrides(
       const gfx::Rect& bounds_override,
       ui::WindowShowState window_state_override) = 0;
 
   // If |value| is true the window can not be moved to another root, regardless
   // of the bounds set on it.
   virtual void SetLockedToRoot(bool value) = 0;
+  virtual bool IsLockedToRoot() const = 0;
 
   virtual void SetCapture() = 0;
   virtual bool HasCapture() = 0;
   virtual void ReleaseCapture() = 0;
 
   virtual bool HasRestoreBounds() const = 0;
 
   virtual void SetAlwaysOnTop(bool value) = 0;
   virtual bool IsAlwaysOnTop() const = 0;
 
   virtual void Hide() = 0;
   virtual void Show() = 0;
 
   // Returns the widget associated with this window, or null if not associated
   // with a widget. Only ash system UI widgets are returned, not widgets created
   // by the mus window manager code to show a non-client frame.
   virtual views::Widget* GetInternalWidget() = 0;
 
   // Requests the window to close and destroy itself. This is intended to
   // forward to an associated widget.
   virtual void CloseWidget() = 0;
 
+  virtual void SetFocused() = 0;
   virtual bool IsFocused() const = 0;
 
   virtual bool IsActive() const = 0;
   virtual void Activate() = 0;
   virtual void Deactivate() = 0;
 
   virtual void SetFullscreen() = 0;
 
   virtual void Maximize() = 0;
   virtual void Minimize() = 0;
@@ skipping 29 matching lines @@
   virtual void SetSnapsChildrenToPhysicalPixelBoundary() = 0;
 
   // If an ancestor has been set to snap children to pixel boundaries, then
   // snaps the layer associated with this window to the layer associated with
   // the ancestor.
   virtual void SnapToPixelBoundaryIfNecessary() = 0;
 
   // Makes the hit region for children slightly larger for easier resizing.
   virtual void SetChildrenUseExtendedHitRegion() = 0;
 
-  // Sets whether descendants of this should not be moved to a different
-  // container. This is used by SetBoundsInScreen().
-  virtual void SetDescendantsStayInSameRootWindow(bool value) = 0;
-
   // Returns a View that renders the contents of this window's layers.
   virtual std::unique_ptr<views::View> CreateViewWithRecreatedLayers() = 0;
 
   virtual void AddObserver(WmWindowObserver* observer) = 0;
   virtual void RemoveObserver(WmWindowObserver* observer) = 0;
   virtual bool HasObserver(const WmWindowObserver* observer) const = 0;
 
   virtual void AddTransientWindowObserver(
       WmTransientWindowObserver* observer) = 0;
   virtual void RemoveTransientWindowObserver(
       WmTransientWindowObserver* observer) = 0;
 
   // Adds or removes a handler to receive events targeted at this window, before
   // this window handles the events itself; the handler does not recieve events
   // from embedded windows. This only supports windows with internal widgets;
   // see GetInternalWidget(). Ownership of the handler is not transferred.
   //
   // Also note that the target of these events is always an aura::Window.
   virtual void AddLimitedPreTargetHandler(ui::EventHandler* handler) = 0;
   virtual void RemoveLimitedPreTargetHandler(ui::EventHandler* handler) = 0;
 
  protected:
   virtual ~WmWindow() {}
 };
 
 }  // namespace ash
 
 #endif  // ASH_COMMON_WM_WINDOW_H_