Converts overview to use common ash types

mash/wm/bridge/wm_window_mus.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 MASH_WM_BRIDGE_WM_WINDOW_MUS_H_
 #define MASH_WM_BRIDGE_WM_WINDOW_MUS_H_
 
 #include <memory>
 
 #include "ash/wm/common/wm_window.h"
@@ skipping 16 matching lines @@
 
 class MusLayoutManagerAdapter;
 class WmRootWindowControllerMus;
 
 // WmWindow implementation for mus.
 //
 // WmWindowMus is tied to the life of the underlying mus::Window (it is stored
 // as an owned property).
 class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
  public:
+  // Indicates the source of the widget creation.
+  enum class WidgetCreationType {
+    // The widget was created internally, and not at the request of a client.
+    INTERNAL,
+
+    // The widget was created for a client. In other words there is a client
+    // embeeded in the mus::Window.

[James Cook, 2016/05/27 00:02:51]

nit: embedded

[sky, 2016/05/27 03:18:04]

Done.

+    FOR_REMOTE,

[James Cook, 2016/05/27 00:02:52]

It took me a long time to wrap my head around the names/docs here. Do you think
it would be clearer to just call this case NON_CLIENT_FRAME or WINDOW_FRAME or
similar? Or do you think it's going to be more generally used?

I guess it took me a while to understand that now there's "internal" widget
creation inside wm/sysui and "external" widget creation like from Chrome or
another app.

[sky, 2016/05/27 03:18:04]

I think that would be confusing as other widgets have NON_CLIENT_FRAMEs too.
I struggled with naming here too. I'm open to something better.

[James Cook, 2016/05/27 16:04:03]

I think I would do something like: INTERNAL and FOR_CLIENT and give examples in
the comments:

The widget was created internally (that is, within ash system UI) and not at the
request of a client app.

and

The widget was created for a client app (e.g. Chrome or other mojo app). In
other words there is a client embedded in the mus::Window.

(I reason better from examples.)

[sky, 2016/05/27 16:58:23]

Done.

+  };
+
   explicit WmWindowMus(mus::Window* window);
   // NOTE: this class is owned by the corresponding window. You shouldn't delete
   // TODO(sky): friend deleter and make private.
   ~WmWindowMus() override;
 
   // Returns a WmWindow for an mus::Window, creating if necessary.
   static WmWindowMus* Get(mus::Window* window);
 
   static WmWindowMus* Get(views::Widget* widget);
 
   static mus::Window* GetMusWindow(ash::wm::WmWindow* wm_window) {
     return const_cast<mus::Window*>(
         GetMusWindow(const_cast<const ash::wm::WmWindow*>(wm_window)));
   }
   static const mus::Window* GetMusWindow(const ash::wm::WmWindow* wm_window);
 
   static std::vector<WmWindow*> FromMusWindows(
       const std::vector<mus::Window*>& mus_windows);
 
   // Sets the widget associated with the window. The widget is used to query
   // state, such as min/max size. The widget is not owned by the WmWindowMus.
-  void set_widget(views::Widget* widget) { widget_ = widget; }
+  void set_widget(views::Widget* widget, WidgetCreationType type) {

[James Cook, 2016/05/27 00:02:51]

SetWidget, given that it's no longer a trivial setter

[sky, 2016/05/27 03:18:04]

It is setting two values, but I they are both ints so I think that qualifies as
trivial. Do you think otherwise?

[James Cook, 2016/05/27 16:30:27]

Yeah, it's fine. The style guide isn't specific about setters: "Functions that
are very cheap to call may instead follow the style for variable names (all
lower-case, with underscores between words). The rule of thumb is that such a
function should be so cheap that you normally wouldn't bother caching its return
value when calling it in a loop." So, yeah, this is cheap to call.

+    widget_ = widget;
+    widget_creation_type_ = type;
+  }
 
   mus::Window* mus_window() { return window_; }
   const mus::Window* mus_window() const { return window_; }
 
   WmRootWindowControllerMus* GetRootWindowControllerMus() {
     return const_cast<WmRootWindowControllerMus*>(
         const_cast<const WmWindowMus*>(this)->GetRootWindowControllerMus());
   }
   const WmRootWindowControllerMus* GetRootWindowControllerMus() const;
 
   static WmWindowMus* AsWmWindowMus(ash::wm::WmWindow* window) {
     return static_cast<WmWindowMus*>(window);
   }
   static const WmWindowMus* AsWmWindowMus(const ash::wm::WmWindow* window) {
     return static_cast<const WmWindowMus*>(window);
   }
 
   ash::wm::WindowState* GetWindowState() {
     return ash::wm::WmWindow::GetWindowState();
   }
 
   // WmWindow:
   const ash::wm::WmWindow* GetRootWindow() const override;
   ash::wm::WmRootWindowController* GetRootWindowController() override;
   ash::wm::WmGlobals* GetGlobals() const override;
+  base::string16 GetTitle() const override;
   void SetShellWindowId(int id) override;
   int GetShellWindowId() const override;
   ash::wm::WmWindow* GetChildByShellWindowId(int id) override;
   ui::wm::WindowType GetType() const override;
   ui::Layer* GetLayer() override;
   display::Display GetDisplayNearestWindow() override;
   bool HasNonClientArea() override;
   int GetNonClientComponent(const gfx::Point& location) override;
   gfx::Point ConvertPointToTarget(const ash::wm::WmWindow* target,
                                   const gfx::Point& point) const override;
   gfx::Point ConvertPointToScreen(const gfx::Point& point) const override;
   gfx::Point ConvertPointFromScreen(const gfx::Point& point) const override;
   gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const override;
   gfx::Rect ConvertRectFromScreen(const gfx::Rect& rect) const override;
   gfx::Size GetMinimumSize() const override;
   gfx::Size GetMaximumSize() const override;
   bool GetTargetVisibility() const override;
   bool IsVisible() const override;
+  void SetOpacity(float opacity) override;
+  float GetTargetOpacity() const override;
+  void SetTransform(const gfx::Transform& transform) override;
+  gfx::Transform GetTargetTransform() const override;
   bool IsSystemModal() const override;
   bool GetBoolProperty(ash::wm::WmWindowProperty key) override;
   int GetIntProperty(ash::wm::WmWindowProperty key) override;
   const ash::wm::WindowState* GetWindowState() const override;
   ash::wm::WmWindow* GetToplevelWindow() override;
   void SetParentUsingContext(ash::wm::WmWindow* context,
                              const gfx::Rect& screen_bounds) override;
   void AddChild(ash::wm::WmWindow* window) override;
   ash::wm::WmWindow* GetParent() override;
   const ash::wm::WmWindow* GetTransientParent() const override;
   std::vector<ash::wm::WmWindow*> GetTransientChildren() override;
   void SetLayoutManager(
       std::unique_ptr<ash::wm::WmLayoutManager> layout_manager) override;
   ash::wm::WmLayoutManager* GetLayoutManager() override;
   void SetVisibilityAnimationType(int type) override;
   void SetVisibilityAnimationDuration(base::TimeDelta delta) override;
+  void SetVisibilityAnimationTransition(
+      ::wm::WindowVisibilityAnimationTransition transition) override;
   void Animate(::wm::WindowAnimationType type) override;
+  void StopAnimatingProperty(
+      ui::LayerAnimationElement::AnimatableProperty property) override;
   void SetBounds(const gfx::Rect& bounds) override;
   void SetBoundsWithTransitionDelay(const gfx::Rect& bounds,
                                     base::TimeDelta delta) override;
   void SetBoundsDirect(const gfx::Rect& bounds) override;
   void SetBoundsDirectAnimated(const gfx::Rect& bounds) override;
   void SetBoundsDirectCrossFade(const gfx::Rect& bounds) override;
   void SetBoundsInScreen(const gfx::Rect& bounds_in_screen,
                          const display::Display& dst_display) override;
   gfx::Rect GetBoundsInScreen() const override;
   const gfx::Rect& GetBounds() const override;
   gfx::Rect GetTargetBounds() override;
   void ClearRestoreBounds() override;
   void SetRestoreBoundsInScreen(const gfx::Rect& bounds) override;
   gfx::Rect GetRestoreBoundsInScreen() const override;
   bool Contains(const ash::wm::WmWindow* other) const override;
   void SetShowState(ui::WindowShowState show_state) override;
   ui::WindowShowState GetShowState() const override;
   void SetRestoreShowState(ui::WindowShowState show_state) override;
   void SetLockedToRoot(bool value) override;
   void SetCapture() override;
   bool HasCapture() override;
   void ReleaseCapture() override;
   bool HasRestoreBounds() const override;
   void SetAlwaysOnTop(bool value) override;
   bool IsAlwaysOnTop() const override;
   void Hide() override;
   void Show() override;
+  void Close() override;
   bool IsFocused() const override;
   bool IsActive() const override;
   void Activate() override;
   void Deactivate() override;
   void SetFullscreen() override;
   void Maximize() override;
   void Minimize() override;
   void Unminimize() override;
   bool CanMaximize() const override;
   bool CanMinimize() const override;
@@ skipping 31 matching lines @@
   mus::Window* window_;
 
   // The shell window id of this window. Shell window ids are defined in
   // ash/wm/common/wm_shell_window_ids.h.
   int shell_window_id_ = -1;
 
   std::unique_ptr<ash::wm::WindowState> window_state_;
 
   views::Widget* widget_ = nullptr;
 
+  WidgetCreationType widget_creation_type_ = WidgetCreationType::INTERNAL;
+
   base::ObserverList<ash::wm::WmWindowObserver> observers_;
 
   std::unique_ptr<MusLayoutManagerAdapter> layout_manager_adapter_;
 
   std::unique_ptr<gfx::Rect> restore_bounds_in_screen_;
 
   ui::WindowShowState restore_show_state_ = ui::SHOW_STATE_DEFAULT;
 
   DISALLOW_COPY_AND_ASSIGN(WmWindowMus);
 };
 
 }  // namespace wm
 }  // namespace mash
 
 #endif  // MASH_WM_BRIDGE_WM_WINDOW_MUS_H_