Remove docked windows entirely in M59.

ash/root_window_controller.cc

 // Copyright (c) 2012 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/root_window_controller.h"
 
 #include <algorithm>
 #include <queue>
 #include <vector>
 
 #include "ash/ash_touch_exploration_manager_chromeos.h"
 #include "ash/aura/aura_layout_manager_adapter.h"
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/system/status_area_layout_manager.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wallpaper/wallpaper_widget_controller.h"
 #include "ash/common/wm/always_on_top_controller.h"
 #include "ash/common/wm/container_finder.h"
-#include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/lock_layout_manager.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/root_window_layout_manager.h"
 #include "ash/common/wm/switchable_windows.h"
 #include "ash/common/wm/system_modal_container_layout_manager.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm/workspace/workspace_layout_manager.h"
 #include "ash/common/wm/workspace_controller.h"
@@ skipping 123 matching lines @@
 }
 
 // Reparents |window| to |new_parent|.
 // TODO(sky): This should take an aura::Window. http://crbug.com/671246.
 void ReparentWindow(WmWindow* window, WmWindow* new_parent) {
   const gfx::Size src_size = window->GetParent()->GetBounds().size();
   const gfx::Size dst_size = new_parent->GetBounds().size();
   // Update the restore bounds to make it relative to the display.
   wm::WindowState* state = window->GetWindowState();
   gfx::Rect restore_bounds;
-  bool has_restore_bounds = state->HasRestoreBounds();
+  const bool has_restore_bounds = state->HasRestoreBounds();
 
-  bool update_bounds =
-      (state->IsNormalOrSnapped() || state->IsMinimized()) &&
-      new_parent->GetShellWindowId() != kShellWindowId_DockedContainer;
+  const bool update_bounds = state->IsNormalOrSnapped() || state->IsMinimized();
   gfx::Rect work_area_in_new_parent =
       wm::GetDisplayWorkAreaBoundsInParent(new_parent);
 
   gfx::Rect local_bounds;
   if (update_bounds) {
     local_bounds = state->window()->GetBounds();
     MoveOriginRelativeToSize(src_size, dst_size, &local_bounds);
     local_bounds.AdjustToFit(work_area_in_new_parent);
   }
 
@@ skipping 12 matching lines @@
   if (has_restore_bounds)
     state->SetRestoreBoundsInParent(restore_bounds);
 }
 
 // Reparents the appropriate set of windows from |src| to |dst|.
 // TODO(sky): This should take an aura::Window. http://crbug.com/671246.
 void ReparentAllWindows(WmWindow* src, WmWindow* dst) {
   // Set of windows to move.
   const int kContainerIdsToMove[] = {
       kShellWindowId_DefaultContainer,
-      kShellWindowId_DockedContainer,
       kShellWindowId_PanelContainer,
       kShellWindowId_AlwaysOnTopContainer,
       kShellWindowId_SystemModalContainer,
       kShellWindowId_LockSystemModalContainer,
       kShellWindowId_UnparentedControlContainer,
       kShellWindowId_OverlayContainer,
   };
   const int kExtraContainerIdsToMoveInUnifiedMode[] = {
       kShellWindowId_LockScreenContainer,
       kShellWindowId_LockScreenWallpaperContainer,
@@ skipping 147 matching lines @@
 
 void RootWindowController::CreateShelfView() {
   if (wm_shelf_->IsShelfInitialized())
     return;
   wm_shelf_->CreateShelfView();
 
   // TODO(jamescook): Pass |wm_shelf_| into the constructors for these layout
   // managers.
   if (panel_layout_manager_)
     panel_layout_manager_->SetShelf(wm_shelf_.get());
-  if (docked_window_layout_manager_) {
-    docked_window_layout_manager_->SetShelf(wm_shelf_.get());
-    if (wm_shelf_->shelf_layout_manager())
-      docked_window_layout_manager_->AddObserver(
-          wm_shelf_->shelf_layout_manager());
-  }
 
   // Notify shell observers that the shelf has been created.
   // TODO(jamescook): Move this into WmShelf::InitializeShelf(). This will
   // require changing AttachedPanelWidgetTargeter's access to WmShelf.
   WmShell::Get()->NotifyShelfCreatedForRootWindow(
       WmWindow::Get(GetRootWindow()));
 
   wm_shelf_->shelf_widget()->PostCreateShelf();
 }
 
@@ skipping 171 matching lines @@
   if (ash_host_)
     ash_host_->PrepareForShutdown();
 
   system_wallpaper_.reset();
   aura::client::SetScreenPositionClient(root_window, nullptr);
 }
 
 void RootWindowController::CloseChildWindows() {
   // NOTE: this may be called multiple times.
 
-  // Remove observer as deactivating keyboard causes
-  // docked_window_layout_manager() to fire notifications.
-  if (docked_window_layout_manager() && wm_shelf_->shelf_layout_manager()) {
-    docked_window_layout_manager()->RemoveObserver(
-        wm_shelf_->shelf_layout_manager());
-  }
-
   // Deactivate keyboard container before closing child windows and shutting
   // down associated layout managers.
   DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
 
   // |panel_layout_manager_| needs to be shut down before windows are destroyed.
   if (panel_layout_manager_) {
     panel_layout_manager_->Shutdown();
     panel_layout_manager_ = nullptr;
   }
 
-  // |docked_window_layout_manager_| needs to be shut down before windows are
-  // destroyed.
-  if (docked_window_layout_manager_) {
-    docked_window_layout_manager_->Shutdown();
-    docked_window_layout_manager_ = nullptr;
-  }
-
   WmShelf* shelf = GetShelf();
   shelf->ShutdownShelfWidget();
 
   workspace_controller_.reset();
 
   // Explicitly destroy top level windows. We do this because such windows may
   // query the RootWindow for state.
   aura::WindowTracker non_toplevel_windows;
   WmWindow* root = GetWindow();
   non_toplevel_windows.Add(root->aura_window());
@@ skipping 59 matching lines @@
 
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
   keyboard_controller->AddObserver(wm_shelf_->shelf_layout_manager());
   keyboard_controller->AddObserver(panel_layout_manager());
-  keyboard_controller->AddObserver(docked_window_layout_manager());
   keyboard_controller->AddObserver(workspace_controller()->layout_manager());
   keyboard_controller->AddObserver(
       always_on_top_controller_->GetLayoutManager());
   WmShell::Get()->NotifyVirtualKeyboardActivated(true);
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   DCHECK(parent);
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   keyboard_container->set_id(kShellWindowId_VirtualKeyboardContainer);
   parent->AddChild(keyboard_container);
 }
 
 void RootWindowController::DeactivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard_controller ||
       !keyboard_controller->keyboard_container_initialized()) {
     return;
   }
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   if (keyboard_container->GetRootWindow() == GetRootWindow()) {
     aura::Window* parent =
         GetContainer(kShellWindowId_ImeWindowParentContainer);
     DCHECK(parent);
     // Virtual keyboard may be deactivated while still showing, hide the
     // keyboard before removing it from view hierarchy.
     keyboard_controller->HideKeyboard(
         keyboard::KeyboardController::HIDE_REASON_AUTOMATIC);
     parent->RemoveChild(keyboard_container);
     keyboard_controller->RemoveObserver(wm_shelf_->shelf_layout_manager());
     keyboard_controller->RemoveObserver(panel_layout_manager());
-    keyboard_controller->RemoveObserver(docked_window_layout_manager());
     keyboard_controller->RemoveObserver(
         workspace_controller()->layout_manager());
     keyboard_controller->RemoveObserver(
         always_on_top_controller_->GetLayoutManager());
     WmShell::Get()->NotifyVirtualKeyboardActivated(false);
   }
 }
 
 bool RootWindowController::IsVirtualKeyboardWindow(aura::Window* window) {
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
@@ skipping 140 matching lines @@
   DCHECK(lock_container);
   lock_container->SetLayoutManager(
       base::MakeUnique<LockLayoutManager>(lock_container));
 
   WmWindow* always_on_top_container =
       GetWmContainer(kShellWindowId_AlwaysOnTopContainer);
   DCHECK(always_on_top_container);
   always_on_top_controller_ =
       base::MakeUnique<AlwaysOnTopController>(always_on_top_container);
 
-  // Create Docked windows layout manager
-  WmWindow* docked_container = GetWmContainer(kShellWindowId_DockedContainer);
-  docked_window_layout_manager_ =
-      new DockedWindowLayoutManager(docked_container);
-  docked_container->SetLayoutManager(
-      base::WrapUnique(docked_window_layout_manager_));
-
   // Create Panel layout manager
   WmWindow* wm_panel_container = GetWmContainer(kShellWindowId_PanelContainer);
   panel_layout_manager_ = new PanelLayoutManager(wm_panel_container);
   wm_panel_container->SetLayoutManager(base::WrapUnique(panel_layout_manager_));
 
   wm::WmSnapToPixelLayoutManager::InstallOnContainers(root);
 
   // Make it easier to resize windows that partially overlap the shelf. Must
   // occur after the ShelfLayoutManager is constructed by ShelfWidget.
   aura::Window* shelf_container = GetContainer(kShellWindowId_ShelfContainer);
@@ skipping 69 matching lines @@
   default_container->SetChildrenUseExtendedHitRegion();
 
   WmWindow* always_on_top_container =
       CreateContainer(kShellWindowId_AlwaysOnTopContainer,
                       "AlwaysOnTopContainer", non_lock_screen_containers);
   always_on_top_container->SetChildWindowVisibilityChangesAnimated();
   always_on_top_container->SetSnapsChildrenToPhysicalPixelBoundary();
   always_on_top_container->SetBoundsInScreenBehaviorForChildren(
       WmWindow::BoundsInScreenBehavior::USE_SCREEN_COORDINATES);
 
-  WmWindow* docked_container =
-      CreateContainer(kShellWindowId_DockedContainer, "DockedContainer",
-                      non_lock_screen_containers);
-  docked_container->SetChildWindowVisibilityChangesAnimated();
-  docked_container->SetSnapsChildrenToPhysicalPixelBoundary();
-  docked_container->SetBoundsInScreenBehaviorForChildren(
-      WmWindow::BoundsInScreenBehavior::USE_SCREEN_COORDINATES);
-  docked_container->SetChildrenUseExtendedHitRegion();
-
   WmWindow* shelf_container =
       CreateContainer(kShellWindowId_ShelfContainer, "ShelfContainer",
                       non_lock_screen_containers);
   shelf_container->SetSnapsChildrenToPhysicalPixelBoundary();
   shelf_container->SetBoundsInScreenBehaviorForChildren(
       WmWindow::BoundsInScreenBehavior::USE_SCREEN_COORDINATES);
   shelf_container->SetLockedToRoot(true);
 
   WmWindow* panel_container =
       CreateContainer(kShellWindowId_PanelContainer, "PanelContainer",
@@ skipping 170 matching lines @@
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash