Prevents panels attached to shelf from docking

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;
 }
@@ skipping 147 matching lines @@
     return pre_auto_manage_window_bounds_.get();
   }
   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 !!window_resizer_; }
+  bool is_dragged() const { return !!window_resizer(); }

[oshima, 2014/01/09 19:13:45]

can you instead use drag_details_ ?

[varkha, 2014/01/10 01:34:50]

I could, but I wanted to preserve the semantics during the resizer creation so
that is_dragged still returns false until the complete chain of resizers is
created.

 
   // 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.
   bool bounds_changed_by_user() const { return bounds_changed_by_user_; }
@@ skipping 35 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;
   }
 
-  // Returns or sets a pointer to WindowResizer when resizing is active.
-  // The pointer to a WindowResizer that is returned is set when a resizer gets
-  // created and cleared when it gets destroyed. WindowState does not own the
-  // |window_resizer_| instance and the resizer's lifetime is controlled
-  // externally. It can be used to avoid creating multiple instances of a
-  // WindowResizer for the same window.
+  // Sets or returns a pointer to DragDetails when resizing is active.
+  // The pointer is set before a resizer gets created and cleared when it gets
+  // destroyed.
+  void set_drag_details(DragDetails* details) {
+    drag_details_.reset(details);
+  }

[oshima, 2014/01/09 19:13:45]

It may be better to have

void CreateDragDetails(args...);
void DeleteDragDetails(); // or ClearDragDetails

instead of letting caller create DragDetails and pass. WDYT?

[varkha, 2014/01/10 01:34:50]

Done. Yes, this allows fewer places to know about DragDetails.

+  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() const {

[oshima, 2014/01/09 19:13:45]

Can you try to remove const? (If it causes a lot of error, then nvm)

[varkha, 2014/01/10 01:34:50]

Done. This forced me to use drag_details_->window_resizer in is_dragged() but
that was all.

-    return window_resizer_;
-  }
-  void set_window_resizer_(WindowResizer* window_resizer) {
-    window_resizer_ = 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);
 
   // Sets the window show type and updates the show state if necessary.
   void SetWindowShowType(WindowShowType new_window_show_type);
 
   // The owner of this window settings.
   aura::Window* window_;
   scoped_ptr<WindowStateDelegate> delegate_;
 
   bool window_position_managed_;
   bool bounds_changed_by_user_;
   bool panel_attached_;
   bool continue_drag_after_reparent_;
   bool ignored_by_shelf_;
   bool can_consume_system_keys_;
   bool top_row_keys_are_function_keys_;
-  WindowResizer* window_resizer_;
+  scoped_ptr<DragDetails> drag_details_;
 
   bool always_restores_to_restore_bounds_;
   bool hide_shelf_when_fullscreen_;
   bool animate_to_fullscreen_;
   bool minimum_visibility_;
 
   // A property to remember the window position which was set before the
   // auto window position manager changed the window bounds, so that it can get
   // restored when only this one window gets shown.
   scoped_ptr<gfx::Rect> pre_auto_manage_window_bounds_;
@@ skipping 17 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_