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

ash/wm/window_state.h

 // Copyright 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.
 
 #ifndef ASH_WM_WINDOW_STATE_H_
 #define ASH_WM_WINDOW_STATE_H_
 
 #include "ash/ash_export.h"
 #include "ash/wm/drag_details.h"
 #include "ash/wm/wm_types.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
 
 namespace aura {
 class Window;
 }
 
 namespace gfx {
 class Rect;
 }
 
 namespace ash {
-class WindowResizer;
 
 namespace wm {
 class WindowStateDelegate;
 class WindowStateObserver;
 
 // WindowState manages and defines ash specific window state and
 // behavior. Ash specific per-window state (such as ones that controls
 // window manager behavior) and ash specific window behavior (such as
 // maximize, minimize, snap sizing etc) should be added here instead
 // of defining separate functions (like |MaximizeWindow(aura::Window*
@@ skipping 131 matching lines @@
   }
   void SetPreAutoManageWindowBounds(const gfx::Rect& bounds);
 
   // Layout related properties
 
   void AddObserver(WindowStateObserver* observer);
   void RemoveObserver(WindowStateObserver* observer);
 
   // Whether the window is being dragged.
   bool is_dragged() const {
-    return drag_details_ && drag_details_->window_resizer;
+    return drag_details_;
   }
 
   // Whether or not the window's position can be managed by the
   // auto management logic.
   bool window_position_managed() const { return window_position_managed_; }
   void set_window_position_managed(bool window_position_managed) {
     window_position_managed_ = window_position_managed;
   }
 
   // Whether or not the window's position or size was changed by a user.
@@ skipping 37 matching lines @@
   // True if this window has requested that the top-row keys (back, forward,
   // brightness, volume) should be treated as function keys.
   bool top_row_keys_are_function_keys() const {
     return top_row_keys_are_function_keys_;
   }
   void set_top_row_keys_are_function_keys(bool value) {
     top_row_keys_are_function_keys_ = value;
   }
 
   // Creates and takes ownership of a pointer to DragDetails when resizing is
-  // active. This should be done before a resizer gets created. Returns true
-  // if |window| is resizable based on |window_component|, false otherwise.
-  bool CreateDragDetails(aura::Window* window,
+  // active. This should be done before a resizer gets created.
+  void CreateDragDetails(aura::Window* window,
                          const gfx::Point& point_in_parent,
                          int window_component,
                          aura::client::WindowMoveSource source);
 
   // Deletes and clears a pointer to DragDetails. This should be done when the
   // resizer gets destroyed.
   void DeleteDragDetails();
 
   // Returns a pointer to DragDetails during drag operations.
   const DragDetails* drag_details() const { return drag_details_.get(); }
   DragDetails* drag_details() { return drag_details_.get(); }
 
-  // Returns a pointer to WindowResizer when resizing is active.
-  // It can be used to avoid creating multiple instances of a WindowResizer for
-  // the same window.
-  WindowResizer* window_resizer() {
-    return drag_details_ ? drag_details_->window_resizer : NULL;
-  }
-
   // aura::WindowObserver overrides:
   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const void* key,
                                        intptr_t old) OVERRIDE;
 
  private:
   // Snaps the window to left or right of the desktop with given bounds.
   void SnapWindow(WindowShowType left_or_right,
                   const gfx::Rect& bounds);
 
@@ skipping 42 matching lines @@
 ASH_EXPORT WindowState* GetWindowState(aura::Window* window);
 
 // const version of GetWindowState.
 ASH_EXPORT const WindowState*
 GetWindowState(const aura::Window* window);
 
 }  // namespace wm
 }  // namespace ash
 
 #endif  // ASH_WM_WINDOW_STATE_H_