Converts DockedWindowLayoutManager to use WmRootWindowControllerObserver

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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 "ash/wm/dock/docked_window_layout_manager.h"
 
-#include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
-#include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/common/window_animation_types.h"
 #include "ash/wm/common/window_parenting_utils.h"
 #include "ash/wm/common/wm_globals.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/window_animations.h"
-#include "ash/wm/window_properties.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_state.h"
-#include "ash/wm/window_state_aura.h"
-#include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
-#include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
-#include "ui/aura/client/focus_client.h"
-#include "ui/aura/client/window_tree_client.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_delegate.h"
-#include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/display.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/views/background.h"
-#include "ui/wm/core/window_util.h"
-#include "ui/wm/public/activation_client.h"
 
 namespace ash {
 
 // Minimum, maximum width of the dock area and a width of the gap
 // static
 const int DockedWindowLayoutManager::kMaxDockWidth = 360;
 // static
 const int DockedWindowLayoutManager::kMinDockWidth = 200;
 // static
 const int DockedWindowLayoutManager::kMinDockGap = 2;
@@ skipping 87 matching lines @@
     params.type = views::Widget::InitParams::TYPE_POPUP;
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
     params.keep_on_top = false;
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.accept_events = false;
     set_focus_on_creation(false);
     parent->GetRootWindowController()->ConfigureWidgetInitParamsForContainer(
         this, parent->GetShellWindowId(), &params);
     Init(params);
     SetVisibilityChangedAnimationsEnabled(false);
-    GetNativeWindow()->SetProperty(kStayInSameRootWindowKey, true);
+    wm::WmWindow* wm_window = wm::WmWindow::Get(this);
+    wm_window->SetLockedToRoot(true);
     opaque_background_.SetColor(SK_ColorBLACK);
     opaque_background_.SetBounds(gfx::Rect(GetWindowBoundsInScreen().size()));
     opaque_background_.SetOpacity(0.0f);
-    GetNativeWindow()->layer()->Add(&opaque_background_);
+    wm_window->GetLayer()->Add(&opaque_background_);
 
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     gfx::ImageSkia shelf_background =
         *rb.GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
     shelf_background_left_ = gfx::ImageSkiaOperations::CreateRotatedImage(
         shelf_background, SkBitmapOperations::ROTATION_90_CW);
     shelf_background_right_ = gfx::ImageSkiaOperations::CreateRotatedImage(
         shelf_background, SkBitmapOperations::ROTATION_270_CW);
 
     // This background should be explicitly stacked below any windows already in
     // the dock, otherwise the z-order is set by the order in which windows were
     // added to the container, and UpdateStacking only manages user windows, not
     // the background widget.
-    parent->StackChildAtBottom(wm::WmWindow::Get(this));
+    parent->StackChildAtBottom(wm_window);
   }
 
   // Transitions to |visible_background_type_| if the widget is visible and to
   // SHELF_BACKGROUND_DEFAULT if it is not.
   void UpdateBackground() {
     ShelfBackgroundType background_type = IsVisible() ?
         visible_background_type_ : SHELF_BACKGROUND_DEFAULT;
     BackgroundAnimatorChangeType change_type = IsVisible() ?
         visible_background_change_type_ : BACKGROUND_CHANGE_IMMEDIATE;
 
@@ skipping 230 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShelfWindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager public implementation:
 DockedWindowLayoutManager::DockedWindowLayoutManager(
     wm::WmWindow* dock_container,
     WorkspaceController* workspace_controller)
     : dock_container_(dock_container),
+      root_window_controller_(dock_container->GetRootWindowController()),
       in_layout_(false),
       dragged_window_(nullptr),
       is_dragged_window_docked_(false),
       is_dragged_from_dock_(false),
       shelf_(nullptr),
       workspace_controller_(workspace_controller),
       in_fullscreen_(workspace_controller_->GetWindowState() ==
                      wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN),
       docked_width_(0),
       alignment_(DOCKED_ALIGNMENT_NONE),
       preferred_alignment_(DOCKED_ALIGNMENT_NONE),
       event_source_(DOCKED_ACTION_SOURCE_UNKNOWN),
       last_active_window_(nullptr),
       last_action_time_(base::Time::Now()),
       background_widget_(nullptr) {
   DCHECK(dock_container);
   dock_container->GetGlobals()->AddActivationObserver(this);
-  Shell::GetInstance()->AddShellObserver(this);
+  root_window_controller_->AddObserver(this);
 }
 
 DockedWindowLayoutManager::~DockedWindowLayoutManager() {
   Shutdown();
 }
 
 // static
 DockedWindowLayoutManager* DockedWindowLayoutManager::Get(
     wm::WmWindow* window) {
   if (!window)
     return nullptr;
 
   wm::WmWindow* root = window->GetRootWindow();
   return static_cast<DockedWindowLayoutManager*>(
       root->GetChildByShellWindowId(kShellWindowId_DockedContainer)
           ->GetLayoutManager());
 }
 
 void DockedWindowLayoutManager::Shutdown() {
   background_widget_.reset();
   shelf_observer_.reset();
   shelf_ = nullptr;
   for (wm::WmWindow* child : dock_container_->GetChildren()) {
     child->RemoveObserver(this);
     child->GetWindowState()->RemoveObserver(this);
   }
   dock_container_->GetGlobals()->RemoveActivationObserver(this);
-  Shell::GetInstance()->RemoveShellObserver(this);
+  root_window_controller_->RemoveObserver(this);
 }
 
 void DockedWindowLayoutManager::AddObserver(
     DockedWindowLayoutManagerObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void DockedWindowLayoutManager::RemoveObserver(
     DockedWindowLayoutManagerObserver* observer) {
   observer_list_.RemoveObserver(observer);
@@ skipping 294 matching lines @@
     return;
   // Whenever one of our windows is moved or resized enforce layout.
   ShelfLayoutManager* shelf_layout = shelf_->shelf_layout_manager();
   if (shelf_layout)
     shelf_layout->UpdateVisibilityState();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, ash::ShellObserver implementation:
 
-void DockedWindowLayoutManager::OnDisplayWorkAreaInsetsChanged() {
+void DockedWindowLayoutManager::OnWorkAreaChanged() {
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::DISPLAY_INSETS_CHANGED);
   MaybeMinimizeChildrenExcept(dragged_window_);
 }
 
-void DockedWindowLayoutManager::OnFullscreenStateChanged(
-    bool is_fullscreen, aura::Window* root_window) {
-  if (dock_container_->GetRootWindow() != wm::WmWindowAura::Get(root_window))
-    return;
+void DockedWindowLayoutManager::OnFullscreenStateChanged(bool is_fullscreen) {
   // Entering fullscreen mode (including immersive) hides docked windows.
   in_fullscreen_ = workspace_controller_->GetWindowState() ==
                    wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN;
   {
     // prevent Relayout from getting called multiple times during this
     base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
     // Use a copy of children array because a call to MinimizeDockedWindow or
     // RestoreDockedWindow can change order.
     for (wm::WmWindow* window : dock_container_->GetChildren()) {
       if (IsPopupOrTransient(window))
         continue;
       wm::WindowState* window_state = window->GetWindowState();
       if (in_fullscreen_) {
         if (window->IsVisible())
           MinimizeDockedWindow(window_state);
       } else {
         if (!window_state->IsMinimized())
           RestoreDockedWindow(window_state);
       }
     }
   }
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
-void DockedWindowLayoutManager::OnShelfAlignmentChanged(
-    aura::Window* root_window) {
-  if (dock_container_->GetRootWindow() != wm::WmWindowAura::Get(root_window))
-    return;
-
+void DockedWindowLayoutManager::OnShelfAlignmentChanged() {
   if (!shelf_ || alignment_ == DOCKED_ALIGNMENT_NONE)
     return;
 
   // Do not allow shelf and dock on the same side. Switch side that
   // the dock is attached to and move all dock windows to that new side.
   ShelfAlignment shelf_alignment = shelf_->alignment();
   if (alignment_ == DOCKED_ALIGNMENT_LEFT &&
       shelf_alignment == SHELF_ALIGNMENT_LEFT) {
     alignment_ = DOCKED_ALIGNMENT_RIGHT;
   } else if (alignment_ == DOCKED_ALIGNMENT_RIGHT &&
@@ skipping 521 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace ash