Random fixes for mash bridge classes

mash/wm/bridge/wm_window_mus.cc

 // 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.
 
 #include "mash/wm/bridge/wm_window_mus.h"
 
 #include "ash/wm/common/container_finder.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_layout_manager.h"
 #include "ash/wm/common/wm_window_observer.h"
@@ skipping 12 matching lines @@
 #include "ui/views/widget/widget_delegate.h"
 
 MUS_DECLARE_WINDOW_PROPERTY_TYPE(mash::wm::WmWindowMus*);
 
 namespace mash {
 namespace wm {
 
 MUS_DEFINE_OWNED_WINDOW_PROPERTY_KEY(mash::wm::WmWindowMus,
                                      kWmWindowKey,
                                      nullptr);
-MUS_DEFINE_LOCAL_WINDOW_PROPERTY_KEY(int, kShellWindowIdKey, -1);
-
 namespace {
 
-mus::Window* GetMusWindowByShellId(mus::Window* window, int id) {
-  if (window->GetLocalProperty(kShellWindowIdKey) == id)
-    return window;
-
-  for (mus::Window* child : window->children()) {
-    mus::Window* result = GetMusWindowByShellId(child, id);
-    if (result)
-      return result;
-  }
-  return nullptr;
-}
-
 // This classes is used so that the WindowState constructor can be made
 // protected. GetWindowState() is the only place that should be creating
 // WindowState.
 class WindowStateMus : public ash::wm::WindowState {
  public:
   explicit WindowStateMus(ash::wm::WmWindow* window)
       : ash::wm::WindowState(window) {}
   ~WindowStateMus() override {}
 
  private:
@@ skipping 99 matching lines @@
 
 ash::wm::WmRootWindowController* WmWindowMus::GetRootWindowController() {
   return GetRootWindowControllerMus();
 }
 
 ash::wm::WmGlobals* WmWindowMus::GetGlobals() const {
   return WmGlobalsMus::Get();
 }
 
 void WmWindowMus::SetShellWindowId(int id) {
-  window_->set_local_id(id);
+  shell_window_id_ = id;
 }
 
 int WmWindowMus::GetShellWindowId() const {
-  return window_->local_id();
+  return shell_window_id_;
 }
 
 ui::wm::WindowType WmWindowMus::GetType() const {
   return GetWmWindowType(window_);
 }
 
 ui::Layer* WmWindowMus::GetLayer() {
   // TODO(sky): this function should be nuked entirely.
   NOTIMPLEMENTED();
   return widget_ ? widget_->GetLayer() : nullptr;
@@ skipping 153 matching lines @@
 
 void WmWindowMus::SetVisibilityAnimationDuration(base::TimeDelta delta) {
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::Animate(::wm::WindowAnimationType type) {
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::SetBounds(const gfx::Rect& bounds) {
-  if (layout_manager_adapter_)
-    layout_manager_adapter_->layout_manager()->SetChildBounds(this, bounds);
-  else
-    window_->SetBounds(bounds);
+  if (window_->parent()) {
+    WmWindowMus* parent = WmWindowMus::Get(window_->parent());
+    if (parent->layout_manager_adapter_) {
+      parent->layout_manager_adapter_->layout_manager()->SetChildBounds(this,
+                                                                        bounds);
+      return;
+    }
+  }
+  SetBoundsDirect(bounds);
 }
 
 void WmWindowMus::SetBoundsWithTransitionDelay(const gfx::Rect& bounds,
                                                base::TimeDelta delta) {
   NOTIMPLEMENTED();
   SetBounds(bounds);
 }
 
 void WmWindowMus::SetBoundsDirect(const gfx::Rect& bounds) {
   window_->SetBounds(bounds);
@@ skipping 12 matching lines @@
 
 void WmWindowMus::SetBoundsInScreen(const gfx::Rect& bounds_in_screen,
                                     const display::Display& dst_display) {
   // TODO(sky): need to find WmRootWindowControllerMus for dst_display and
   // convert.
   NOTIMPLEMENTED();
   SetBounds(ConvertRectFromScreen(bounds_in_screen));
 }
 
 gfx::Rect WmWindowMus::GetBoundsInScreen() const {
-  return ConvertRectToScreen(window_->bounds());
+  return ConvertRectToScreen(gfx::Rect(window_->bounds().size()));
 }
 
 const gfx::Rect& WmWindowMus::GetBounds() const {
   return window_->bounds();
 }
 
 gfx::Rect WmWindowMus::GetTargetBounds() {
   NOTIMPLEMENTED();
   return window_->bounds();
 }
@@ skipping 110 matching lines @@
   return window_->HasFocus();
 }
 
 bool WmWindowMus::IsActive() const {
   mus::Window* focused = window_->connection()->GetFocusedWindow();
   return focused && window_->Contains(focused);
 }
 
 void WmWindowMus::Activate() {
   window_->SetFocus();
+  ash::wm::WmWindow* top_level = GetToplevelWindow();
+  if (!top_level)
+    return;
+
+  // TODO(sky): mus should do this too.
+  GetMusWindow(top_level)->MoveToFront();
 }
 
 void WmWindowMus::Deactivate() {
   if (IsActive())
     window_->connection()->ClearFocus();
 }
 
 void WmWindowMus::SetFullscreen() {
   SetWindowShowState(window_, mus::mojom::ShowState::FULLSCREEN);
 }
 
 void WmWindowMus::Maximize() {
   SetWindowShowState(window_, mus::mojom::ShowState::MAXIMIZED);
 }
 
 void WmWindowMus::Minimize() {
   SetWindowShowState(window_, mus::mojom::ShowState::MINIMIZED);
 }
 
 void WmWindowMus::Unminimize() {
   SetWindowShowState(window_, MojomWindowShowStateFromUI(restore_show_state_));
   restore_show_state_ = ui::SHOW_STATE_DEFAULT;
 }
 
 std::vector<ash::wm::WmWindow*> WmWindowMus::GetChildren() {
   return FromMusWindows(window_->children());
 }
 
 ash::wm::WmWindow* WmWindowMus::GetChildByShellWindowId(int id) {
-  return Get(GetMusWindowByShellId(window_, id));
+  if (id == shell_window_id_)
+    return this;
+  for (mus::Window* child : window_->children()) {
+    ash::wm::WmWindow* result = Get(child)->GetChildByShellWindowId(id);
+    if (result)
+      return result;
+  }
+  return nullptr;
 }
 
 void WmWindowMus::SnapToPixelBoundaryIfNecessary() {
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::AddObserver(ash::wm::WmWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WmWindowMus::RemoveObserver(ash::wm::WmWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void WmWindowMus::NotifyStackingChanged() {
-  FOR_EACH_OBSERVER(ash::wm::WmWindowObserver, observers_,
-                    OnWindowStackingChanged(this));
-}
-
 void WmWindowMus::OnTreeChanged(const TreeChangeParams& params) {
   ash::wm::WmWindowObserver::TreeChangeParams wm_params;
   wm_params.target = Get(params.target);
   wm_params.new_parent = Get(params.new_parent);
   wm_params.old_parent = Get(params.old_parent);
   FOR_EACH_OBSERVER(ash::wm::WmWindowObserver, observers_,
                     OnWindowTreeChanged(this, wm_params));
 }
 
 void WmWindowMus::OnWindowReordered(mus::Window* window,
                                     mus::Window* relative_window,
                                     mus::mojom::OrderDirection direction) {
-  if (!window_->parent())
-    return;
-
-  static_cast<WmWindowMus*>(Get(window_->parent()))->NotifyStackingChanged();
+  FOR_EACH_OBSERVER(ash::wm::WmWindowObserver, observers_,
+                    OnWindowStackingChanged(this));
 }
 
 void WmWindowMus::OnWindowSharedPropertyChanged(
     mus::Window* window,
     const std::string& name,
     const std::vector<uint8_t>* old_data,
     const std::vector<uint8_t>* new_data) {
+  if (name == mus::mojom::WindowManager::kShowState_Property)
+    GetWindowState()->OnWindowShowStateChanged();
+
   // Deal with always on top and snap.
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::OnWindowBoundsChanged(mus::Window* window,
                                         const gfx::Rect& old_bounds,
                                         const gfx::Rect& new_bounds) {
   FOR_EACH_OBSERVER(ash::wm::WmWindowObserver, observers_,
                     OnWindowBoundsChanged(this, old_bounds, new_bounds));
 }
 
 void WmWindowMus::OnWindowDestroying(mus::Window* window) {
   FOR_EACH_OBSERVER(ash::wm::WmWindowObserver, observers_,
                     OnWindowDestroying(this));
 }
 
 }  // namespace wm
 }  // namespace mash