[Refactor] Kill some dead code because it is no longer possible to drag maximized windows

ash/wm/workspace/workspace_window_resizer.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_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 34 matching lines @@
 scoped_ptr<WindowResizer> CreateWindowResizer(
     aura::Window* window,
     const gfx::Point& point_in_parent,
     int window_component,
     aura::client::WindowMoveSource source) {
   DCHECK(window);
   wm::WindowState* window_state = wm::GetWindowState(window);
   // No need to return a resizer when the window cannot get resized or when a
   // resizer already exists for this window.
   if ((!window_state->CanResize() && window_component != HTCAPTION) ||
-      window_state->window_resizer()) {
+      window_state->drag_details()) {
     return scoped_ptr<WindowResizer>();
   }
 
   // TODO(varkha): The chaining of window resizers causes some of the logic
   // to be repeated and the logic flow difficult to control. With some windows
   // classes using reparenting during drag operations it becomes challenging to
   // implement proper transition from one resizer to another during or at the
   // end of the drag. This also causes http://crbug.com/247085.
   // It seems the only thing the panel or dock resizer needs to do is notify the
   // layout manager when a docked window is being dragged. We should have a
   // better way of doing this, perhaps by having a way of observing drags or
   // having a generic drag window wrapper which informs a layout manager that a
   // drag has started or stopped.
   // It may be possible to refactor and eliminate chaining.
   WindowResizer* window_resizer = NULL;
 
-  if (!window_state->IsNormalShowState()) {
-    if (window->parent() &&
-        (window->parent()->id() == internal::kShellWindowId_DefaultContainer ||
-         window->parent()->id() == internal::kShellWindowId_DockedContainer ||
-         window->parent()->id() == internal::kShellWindowId_PanelContainer)) {
-      // Allow dragging maximized windows only when dragged by a tab.
-      if (window_component != HTCAPTION || !window_state->is_dragged())
-        return scoped_ptr<WindowResizer>();
-    } else {
-      return scoped_ptr<WindowResizer>();
-    }
-  }
+  if (!window_state->IsNormalShowState())
+    return scoped_ptr<WindowResizer>();
 
-  if (!window_state->CreateDragDetails(
-      window, point_in_parent, window_component, source)) {
+  int bounds_change = WindowResizer::GetBoundsChangeForWindowComponent(
+      window_component);
+  if (bounds_change == WindowResizer::kBoundsChangeDirection_None)
     return scoped_ptr<WindowResizer>();
-  }
+
+  window_state->CreateDragDetails(window, point_in_parent, window_component,
+      source);
   if (window->parent() &&
       (window->parent()->id() == internal::kShellWindowId_DefaultContainer ||
        window->parent()->id() == internal::kShellWindowId_DockedContainer ||
        window->parent()->id() == internal::kShellWindowId_PanelContainer)) {
     window_resizer = internal::WorkspaceWindowResizer::Create(
         window_state,
         std::vector<aura::Window*>());
   } else {
     window_resizer = DefaultWindowResizer::Create(window_state);
   }
-  if (window_resizer) {
-    window_resizer = internal::DragWindowResizer::Create(window_resizer,
-                                                         window_state);
-  }
-  if (window_resizer && window->type() == ui::wm::WINDOW_TYPE_PANEL)
+  window_resizer = internal::DragWindowResizer::Create(window_resizer,
+                                                       window_state);
+  if (window->type() == ui::wm::WINDOW_TYPE_PANEL)
     window_resizer = PanelWindowResizer::Create(window_resizer, window_state);
   if (switches::UseDockedWindows() &&
       window_resizer && window->parent() &&
       !views::corewm::GetTransientParent(window) &&
       (window->parent()->id() == internal::kShellWindowId_DefaultContainer ||
        window->parent()->id() == internal::kShellWindowId_DockedContainer ||
        window->parent()->id() == internal::kShellWindowId_PanelContainer)) {
     window_resizer = internal::DockedWindowResizer::Create(window_resizer,
                                                            window_state);
   }
-  window_state->drag_details()->window_resizer = window_resizer;
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
 // Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
 // when resizing a window using touchscreen.
 const int kScreenEdgeInsetForTouchResize = 32;
@@ skipping 252 matching lines @@
       switches::kAshEnableStickyEdges)) {
     sticky_size = kStickyDistancePixels;
   } else if ((details().bounds_change & kBoundsChange_Resizes) &&
       details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchResize;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |GetTarget()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(location_in_parent);
-  if (window_state()->IsNormalShowState())
-    AdjustBoundsForMainWindow(sticky_size, &bounds);
+  AdjustBoundsForMainWindow(sticky_size, &bounds);
 
   if (bounds != GetTarget()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details().restore_bounds.IsEmpty())
         window_state()->ClearRestoreBounds();
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
@@ skipping 637 matching lines @@
   } else {
     if (dock_layout_->is_dragged_window_docked()) {
       dock_layout_->UndockDraggedWindow();
       window_state()->set_bounds_changed_by_user(true);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash