Cleanup WorkspaceController and WorkspaceLayoutManager.

ash/wm/workspace/workspace_layout_manager.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/wm/workspace/workspace_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_state_delegate.h"
-#include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace/workspace_layout_manager_delegate.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/gfx/screen.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
-using aura::Window;
-
 namespace ash {
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(aura::Window* window)
-    : shelf_(NULL),
-      window_(window),
-      root_window_(window->GetRootWindow()),
+    : window_(window),
+      root_window_(window_->GetRootWindow()),
+      root_window_controller_(GetRootWindowController(root_window_)),
       work_area_in_parent_(ScreenUtil::ConvertRectFromScreen(
           window_,
           gfx::Screen::GetScreen()
               ->GetDisplayNearestWindow(window_)
               .work_area())),
-      is_fullscreen_(GetRootWindowController(window->GetRootWindow())
-                         ->GetWindowForFullscreenMode() != NULL) {
+      is_fullscreen_(root_window_controller_->GetWindowForFullscreenMode() !=
+                     nullptr) {
   Shell::GetInstance()->activation_client()->AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
   root_window_->AddObserver(this);
   DCHECK(window->GetProperty(kSnapChildrenToPixelBoundary));
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
   if (root_window_)
     root_window_->RemoveObserver(this);
-  for (WindowSet::const_iterator i = windows_.begin(); i != windows_.end(); ++i)
-    (*i)->RemoveObserver(this);
+  for (auto window : windows_)

[oshima, 2016/03/29 22:42:25]

nit: auto*

[msw, 2016/03/29 22:48:00]

Done here and in this file's other similar loops.

+    window->RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
   Shell::GetInstance()->activation_client()->RemoveObserver(this);
 }
 
-void WorkspaceLayoutManager::SetShelf(ShelfLayoutManager* shelf) {
-  shelf_ = shelf;
-}
-
 void WorkspaceLayoutManager::SetMaximizeBackdropDelegate(
     scoped_ptr<WorkspaceLayoutManagerDelegate> delegate) {
   backdrop_delegate_.reset(delegate.release());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::LayoutManager implementation:
 
-void WorkspaceLayoutManager::OnWindowAddedToLayout(Window* child) {
+void WorkspaceLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   wm::WMEvent event(wm::WM_EVENT_ADDED_TO_WORKSPACE);
   window_state->OnWMEvent(&event);
   windows_.insert(child);
   child->AddObserver(this);
   window_state->AddObserver(this);
-  UpdateShelfVisibility();
+  root_window_controller_->UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
     backdrop_delegate_->OnWindowAddedToLayout(child);
   WindowPositioner::RearrangeVisibleWindowOnShow(child);
 }
 
-void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(Window* child) {
+void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   windows_.erase(child);
   child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
 
   if (child->TargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
 }
 
-void WorkspaceLayoutManager::OnWindowRemovedFromLayout(Window* child) {
-  UpdateShelfVisibility();
+void WorkspaceLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
+  root_window_controller_->UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
     backdrop_delegate_->OnWindowRemovedFromLayout(child);
 }
 
-void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(Window* child,
+void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(aura::Window* child,
                                                             bool visible) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   // Attempting to show a minimized window. Unminimize it.
   if (visible && window_state->IsMinimized())
     window_state->Unminimize();
 
   if (child->TargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnShow(child);
   else
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
   UpdateFullscreenState();
-  UpdateShelfVisibility();
+  root_window_controller_->UpdateShelfVisibility();
   if (backdrop_delegate_)
     backdrop_delegate_->OnChildWindowVisibilityChanged(child, visible);
 }
 
-void WorkspaceLayoutManager::SetChildBounds(
-    Window* child,
-    const gfx::Rect& requested_bounds) {
+void WorkspaceLayoutManager::SetChildBounds(aura::Window* child,
+                                            const gfx::Rect& requested_bounds) {
   wm::WindowState* window_state = wm::GetWindowState(child);
   wm::SetBoundsEvent event(wm::WM_EVENT_SET_BOUNDS, requested_bounds);
   window_state->OnWMEvent(&event);
-  UpdateShelfVisibility();
+  root_window_controller_->UpdateShelfVisibility();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, keyboard::KeyboardControllerObserver implementation:
 
 void WorkspaceLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& new_bounds) {
   aura::Window* window = wm::GetActiveWindow()->GetToplevelWindow();
   if (!window || !window_->Contains(window))
     return;
@@ skipping 35 matching lines @@
     const wm::WMEvent event(wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
     AdjustAllWindowsBoundsForWorkAreaChange(&event);
   }
   if (backdrop_delegate_)
     backdrop_delegate_->OnDisplayWorkAreaInsetsChanged();
 }
 
 void WorkspaceLayoutManager::OnFullscreenStateChanged(
     bool is_fullscreen,
     aura::Window* root_window) {
-  if (window_->GetRootWindow() != root_window ||
-      is_fullscreen_ == is_fullscreen) {
+  if (root_window_ != root_window || is_fullscreen_ == is_fullscreen)
     return;
-  }
   is_fullscreen_ = is_fullscreen;
-  Window* fullscreen_window =
-      is_fullscreen
-          ? GetRootWindowController(window_->GetRootWindow())
-                ->GetWindowForFullscreenMode()
-          : NULL;
+  aura::Window* fullscreen_window =
+      is_fullscreen ? root_window_controller_->GetWindowForFullscreenMode()
+                    : nullptr;
   // Changing always on top state may change window's parent. Iterate on a copy
   // of |windows_| to avoid invalidating an iterator. Since both workspace and
   // always_on_top containers' layouts are managed by this class all the
   // appropriate windows will be included in the iteration.
   WindowSet windows(windows_);
   for (auto window : windows) {
     wm::WindowState* window_state = wm::GetWindowState(window);
     if (is_fullscreen)
       window_state->DisableAlwaysOnTop(fullscreen_window);
     else
@@ skipping 13 matching lines @@
   // OnWindowAddedToLayout.
   if (windows_.find(params.target) != windows_.end())
     return;
 
   // If the active window has moved to this root window then update the
   // fullscreen state.
   // TODO(flackr): Track the active window leaving this root window and update
   // the fullscreen state accordingly.
   if (params.new_parent && params.new_parent->GetRootWindow() == root_window_) {
     UpdateFullscreenState();
-    UpdateShelfVisibility();
+    root_window_controller_->UpdateShelfVisibility();
   }
 }
 
-void WorkspaceLayoutManager::OnWindowPropertyChanged(Window* window,
+void WorkspaceLayoutManager::OnWindowPropertyChanged(aura::Window* window,
                                                      const void* key,
                                                      intptr_t old) {
   if (key == aura::client::kAlwaysOnTopKey &&
       window->GetProperty(aura::client::kAlwaysOnTopKey)) {
     GetRootWindowController(window->GetRootWindow())->
         always_on_top_controller()->GetContainer(window)->AddChild(window);
   }
 }
 
 void WorkspaceLayoutManager::OnWindowStackingChanged(aura::Window* window) {
-  UpdateShelfVisibility();
+  root_window_controller_->UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
     backdrop_delegate_->OnWindowStackingChanged(window);
 }
 
 void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
-    root_window_ = NULL;
+    root_window_ = nullptr;
   }
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(aura::Window* window,
                                               const gfx::Rect& old_bounds,
                                               const gfx::Rect& new_bounds) {
   if (root_window_ == window) {
     const wm::WMEvent wm_event(wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED);
     AdjustAllWindowsBoundsForWorkAreaChange(&wm_event);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager,
 // aura::client::ActivationChangeObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   wm::WindowState* window_state = wm::GetWindowState(gained_active);
   if (window_state && window_state->IsMinimized() &&
       !gained_active->IsVisible()) {
     window_state->Unminimize();
     DCHECK(!window_state->IsMinimized());
   }
   UpdateFullscreenState();
-  UpdateShelfVisibility();
+  root_window_controller_->UpdateShelfVisibility();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, wm::WindowStateObserver implementation:
 
 void WorkspaceLayoutManager::OnPostWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old_type) {
 
   // Notify observers that fullscreen state may be changing.
   if (window_state->IsFullscreen() ||
       old_type == wm::WINDOW_STATE_TYPE_FULLSCREEN) {
     UpdateFullscreenState();
   }
 
-  UpdateShelfVisibility();
+  root_window_controller_->UpdateShelfVisibility();
   if (backdrop_delegate_)
     backdrop_delegate_->OnPostWindowStateTypeChange(window_state, old_type);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, private:
 
 void WorkspaceLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(
     const wm::WMEvent* event) {
   DCHECK(event->type() == wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED ||
          event->type() == wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
 
   work_area_in_parent_ = ScreenUtil::ConvertRectFromScreen(
       window_,
       gfx::Screen::GetScreen()->GetDisplayNearestWindow(window_).work_area());
 
   // Don't do any adjustments of the insets while we are in screen locked mode.
   // This would happen if the launcher was auto hidden before the login screen
   // was shown and then gets shown when the login screen gets presented.
   if (event->type() == wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED &&
       Shell::GetInstance()->session_state_delegate()->IsScreenLocked())
     return;
 
   // If a user plugs an external display into a laptop running Aura the
   // display size will change.  Maximized windows need to resize to match.
   // We also do this when developers running Aura on a desktop manually resize
   // the host window.
   // We also need to do this when the work area insets changes.
-  for (WindowSet::const_iterator it = windows_.begin();
-       it != windows_.end();
-       ++it) {
-    wm::GetWindowState(*it)->OnWMEvent(event);
-  }
-}
-
-void WorkspaceLayoutManager::UpdateShelfVisibility() {
-  if (shelf_)
-    shelf_->UpdateVisibilityState();
+  for (auto window : windows_)
+    wm::GetWindowState(window)->OnWMEvent(event);
 }
 
 void WorkspaceLayoutManager::UpdateFullscreenState() {
   // TODO(flackr): The fullscreen state is currently tracked per workspace
   // but the shell notification implies a per root window state. Currently
   // only windows in the default workspace container will go fullscreen but
   // this should really be tracked by the RootWindowController since
   // technically any container could get a fullscreen window.
-  if (!shelf_)
-    return;
-  bool is_fullscreen = GetRootWindowController(
-      window_->GetRootWindow())->GetWindowForFullscreenMode() != NULL;
+  bool is_fullscreen =
+      root_window_controller_->GetWindowForFullscreenMode() != nullptr;
   if (is_fullscreen != is_fullscreen_) {
-    ash::Shell::GetInstance()->NotifyFullscreenStateChange(
-        is_fullscreen, window_->GetRootWindow());
+    ash::Shell::GetInstance()->NotifyFullscreenStateChange(is_fullscreen,
+                                                           root_window_);
     is_fullscreen_ = is_fullscreen;
   }
 }
 
 }  // namespace ash