Cleanup WorkspaceController and WorkspaceLayoutManager.

ash/wm/workspace_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/wm/workspace_controller.h"
 
 #include <utility>
 
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 24 matching lines @@
 // Returns true if there are visible docked windows in the same screen as the
 // |shelf|.
 bool IsDockedAreaVisible(const ShelfLayoutManager* shelf) {
   return shelf->dock_bounds().width() > 0;
 }
 
 }  // namespace
 
 WorkspaceController::WorkspaceController(aura::Window* viewport)
     : viewport_(viewport),
-      shelf_(NULL),
+      shelf_(nullptr),
       event_handler_(new WorkspaceEventHandler),
       layout_manager_(new WorkspaceLayoutManager(viewport)) {
   SetWindowVisibilityAnimationTransition(
       viewport_, ::wm::ANIMATE_NONE);
 
   viewport_->SetLayoutManager(layout_manager_);
   viewport_->AddPreTargetHandler(event_handler_.get());
 }
 
 WorkspaceController::~WorkspaceController() {
-  viewport_->SetLayoutManager(NULL);
+  viewport_->SetLayoutManager(nullptr);
   viewport_->RemovePreTargetHandler(event_handler_.get());
 }
 
 WorkspaceWindowState WorkspaceController::GetWindowState() const {
   if (!shelf_)
     return WORKSPACE_WINDOW_STATE_DEFAULT;
   const aura::Window* topmost_fullscreen_window = GetRootWindowController(
       viewport_->GetRootWindow())->GetWindowForFullscreenMode();
   if (topmost_fullscreen_window &&
       !wm::GetWindowState(topmost_fullscreen_window)->ignored_by_shelf()) {
     return WORKSPACE_WINDOW_STATE_FULL_SCREEN;
   }
 
   // These are the container ids of containers which may contain windows that
   // may overlap the launcher shelf and affect its transparency.
   const int kWindowContainerIds[] = {kShellWindowId_DefaultContainer,
-                                     kShellWindowId_DockedContainer, };
+                                     kShellWindowId_DockedContainer};
   const gfx::Rect shelf_bounds(shelf_->GetIdealBounds());
+
   bool window_overlaps_launcher = false;
   for (size_t idx = 0; idx < arraysize(kWindowContainerIds); idx++) {
     const aura::Window* container = Shell::GetContainer(
         viewport_->GetRootWindow(), kWindowContainerIds[idx]);
     const aura::Window::Windows& windows(container->children());
-    for (aura::Window::Windows::const_iterator i = windows.begin();
-         i != windows.end(); ++i) {
-      wm::WindowState* window_state = wm::GetWindowState(*i);
+    for (auto window : windows) {

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

nit: auto*

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

Done.

+      wm::WindowState* window_state = wm::GetWindowState(window);
       if (window_state->ignored_by_shelf())
         continue;
-      ui::Layer* layer = (*i)->layer();
-      if (!layer->GetTargetVisibility())
+      if (!window->layer()->GetTargetVisibility())
         continue;
       if (window_state->IsMaximized())
         return WORKSPACE_WINDOW_STATE_MAXIMIZED;
-      if (!window_overlaps_launcher &&
-          ((*i)->bounds().Intersects(shelf_bounds))) {
-        window_overlaps_launcher = true;
-      }
+      window_overlaps_launcher |= window->bounds().Intersects(shelf_bounds);
     }
   }
 
   return (window_overlaps_launcher || IsDockedAreaVisible(shelf_)) ?
       WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF :
       WORKSPACE_WINDOW_STATE_DEFAULT;
 }
 
-void WorkspaceController::SetShelf(ShelfLayoutManager* shelf) {
-  shelf_ = shelf;
-  layout_manager_->SetShelf(shelf);
-}
-
 void WorkspaceController::DoInitialAnimation() {
   viewport_->Show();
 
   viewport_->layer()->SetOpacity(0.0f);
   SetTransformForScaleAnimation(
       viewport_->layer(), LAYER_SCALE_ANIMATION_ABOVE);
 
   // In order for pause to work we need to stop animations.
   viewport_->layer()->GetAnimator()->StopAnimating();
 
@@ skipping 15 matching lines @@
     viewport_->layer()->SetOpacity(1.0f);
   }
 }
 
 void WorkspaceController::SetMaximizeBackdropDelegate(
     scoped_ptr<WorkspaceLayoutManagerDelegate> delegate) {
   layout_manager_->SetMaximizeBackdropDelegate(std::move(delegate));
 }
 
 }  // namespace ash