Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(881)

Side by Side Diff: ash/wm/dock/docked_window_resizer.cc

Issue 1901593004: Removes most aura dependencies from DockedWindowResizer (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@window_resizer
Patch Set: branch from master Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « ash/wm/dock/docked_window_resizer.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "ash/wm/dock/docked_window_resizer.h" 5 #include "ash/wm/dock/docked_window_resizer.h"
6 6
7 #include "ash/display/window_tree_host_manager.h"
8 #include "ash/root_window_controller.h"
9 #include "ash/screen_util.h"
10 #include "ash/shelf/shelf.h"
11 #include "ash/shelf/shelf_types.h"
12 #include "ash/shelf/shelf_widget.h"
13 #include "ash/shell.h"
14 #include "ash/shell_window_ids.h" 7 #include "ash/shell_window_ids.h"
15 #include "ash/wm/aura/wm_window_aura.h" 8 #include "ash/wm/aura/wm_window_aura.h"
16 #include "ash/wm/common/window_parenting_utils.h" 9 #include "ash/wm/common/window_parenting_utils.h"
17 #include "ash/wm/common/wm_event.h" 10 #include "ash/wm/common/wm_event.h"
11 #include "ash/wm/common/wm_root_window_controller.h"
12 #include "ash/wm/common/wm_window.h"
18 #include "ash/wm/dock/docked_window_layout_manager.h" 13 #include "ash/wm/dock/docked_window_layout_manager.h"
19 #include "ash/wm/window_state.h" 14 #include "ash/wm/window_state.h"
20 #include "ash/wm/window_state_aura.h"
21 #include "ash/wm/window_util.h"
22 #include "ash/wm/workspace/magnetism_matcher.h" 15 #include "ash/wm/workspace/magnetism_matcher.h"
23 #include "ash/wm/workspace/workspace_window_resizer.h"
24 #include "base/command_line.h"
25 #include "base/memory/weak_ptr.h"
26 #include "ui/aura/client/aura_constants.h"
27 #include "ui/aura/client/window_tree_client.h"
28 #include "ui/aura/env.h"
29 #include "ui/aura/window.h" 16 #include "ui/aura/window.h"
30 #include "ui/aura/window_delegate.h"
31 #include "ui/aura/window_event_dispatcher.h"
32 #include "ui/base/hit_test.h" 17 #include "ui/base/hit_test.h"
33 #include "ui/base/ui_base_types.h" 18 #include "ui/base/ui_base_types.h"
34 #include "ui/gfx/screen.h" 19 #include "ui/gfx/screen.h"
35 #include "ui/views/widget/widget.h"
36 #include "ui/wm/core/coordinate_conversion.h"
37 20
38 namespace ash { 21 namespace ash {
39 namespace { 22 namespace {
40 23
24 DockedWindowLayoutManager* GetDockedLayoutManagerInRoot(wm::WmWindow* root) {
25 wm::WmWindow* dock_container =
26 root->GetChildByShellWindowId(kShellWindowId_DockedContainer);
27 return static_cast<DockedWindowLayoutManager*>(
28 wm::WmWindowAura::GetAuraWindow(dock_container)->layout_manager());
29 }
30
41 DockedWindowLayoutManager* GetDockedLayoutManagerAtPoint( 31 DockedWindowLayoutManager* GetDockedLayoutManagerAtPoint(
42 const gfx::Point& point) { 32 const gfx::Point& point) {
43 gfx::Display display = ScreenUtil::FindDisplayContainingPoint(point); 33 gfx::Display display =
44 if (!display.is_valid()) 34 gfx::Screen::GetScreen()->GetDisplayNearestPoint(point);
45 return NULL; 35 if (!display.bounds().Contains(point))
46 aura::Window* root = Shell::GetInstance() 36 return nullptr;
47 ->window_tree_host_manager() 37
48 ->GetRootWindowForDisplayId(display.id()); 38 return GetDockedLayoutManagerInRoot(
49 aura::Window* dock_container = Shell::GetContainer( 39 wm::WmRootWindowController::GetWithDisplayId(display.id())->GetWindow());
50 root, kShellWindowId_DockedContainer);
51 return static_cast<DockedWindowLayoutManager*>(
52 dock_container->layout_manager());
53 } 40 }
54 41
55 } // namespace 42 } // namespace
56 43
57 DockedWindowResizer::~DockedWindowResizer() { 44 DockedWindowResizer::~DockedWindowResizer() {
58 } 45 }
59 46
60 // static 47 // static
61 DockedWindowResizer* 48 DockedWindowResizer*
62 DockedWindowResizer::Create(WindowResizer* next_window_resizer, 49 DockedWindowResizer::Create(WindowResizer* next_window_resizer,
63 wm::WindowState* window_state) { 50 wm::WindowState* window_state) {
64 return new DockedWindowResizer(next_window_resizer, window_state); 51 return new DockedWindowResizer(next_window_resizer, window_state);
65 } 52 }
66 53
67 void DockedWindowResizer::Drag(const gfx::Point& location, int event_flags) { 54 void DockedWindowResizer::Drag(const gfx::Point& location, int event_flags) {
68 last_location_ = location; 55 last_location_ = GetTarget()->GetParent()->ConvertPointToScreen(location);
69 ::wm::ConvertPointToScreen(GetAuraTarget()->parent(), &last_location_);
70 base::WeakPtr<DockedWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr()); 56 base::WeakPtr<DockedWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr());
71 57
72 if (!did_move_or_resize_) { 58 if (!did_move_or_resize_) {
73 did_move_or_resize_ = true; 59 did_move_or_resize_ = true;
74 StartedDragging(resizer); 60 StartedDragging(resizer);
75 } 61 }
76 if (!resizer) 62 if (!resizer)
77 return; 63 return;
78 64
79 gfx::Point offset; 65 gfx::Point offset;
80 gfx::Rect bounds(CalculateBoundsForDrag(location)); 66 gfx::Rect bounds(CalculateBoundsForDrag(location));
81 MaybeSnapToEdge(bounds, &offset); 67 MaybeSnapToEdge(bounds, &offset);
82 gfx::Point modified_location(location); 68 gfx::Point modified_location(location);
83 modified_location.Offset(offset.x(), offset.y()); 69 modified_location += offset.OffsetFromOrigin();
84 70
85 next_window_resizer_->Drag(modified_location, event_flags); 71 next_window_resizer_->Drag(modified_location, event_flags);
86 if (!resizer) 72 if (!resizer)
87 return; 73 return;
88 74
89 DockedWindowLayoutManager* new_dock_layout = 75 DockedWindowLayoutManager* new_dock_layout =
90 GetDockedLayoutManagerAtPoint(last_location_); 76 GetDockedLayoutManagerAtPoint(last_location_);
91 if (new_dock_layout && new_dock_layout != dock_layout_) { 77 if (new_dock_layout && new_dock_layout != dock_layout_) {
92 // The window is being dragged to a new display. If the previous 78 // The window is being dragged to a new display. If the previous
93 // container is the current parent of the window it will be informed of 79 // container is the current parent of the window it will be informed of
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
141 : WindowResizer(window_state), 127 : WindowResizer(window_state),
142 next_window_resizer_(next_window_resizer), 128 next_window_resizer_(next_window_resizer),
143 dock_layout_(NULL), 129 dock_layout_(NULL),
144 initial_dock_layout_(NULL), 130 initial_dock_layout_(NULL),
145 did_move_or_resize_(false), 131 did_move_or_resize_(false),
146 was_docked_(false), 132 was_docked_(false),
147 is_docked_(false), 133 is_docked_(false),
148 was_bounds_changed_by_user_(window_state->bounds_changed_by_user()), 134 was_bounds_changed_by_user_(window_state->bounds_changed_by_user()),
149 weak_ptr_factory_(this) { 135 weak_ptr_factory_(this) {
150 DCHECK(details().is_resizable); 136 DCHECK(details().is_resizable);
151 aura::Window* dock_container = Shell::GetContainer( 137 wm::WmWindow* dock_container =
152 GetAuraTarget()->GetRootWindow(), kShellWindowId_DockedContainer); 138 GetTarget()->GetRootWindow()->GetChildByShellWindowId(
153 dock_layout_ = static_cast<DockedWindowLayoutManager*>( 139 kShellWindowId_DockedContainer);
154 dock_container->layout_manager()); 140 dock_layout_ = GetDockedLayoutManagerInRoot(GetTarget()->GetRootWindow());
155 initial_dock_layout_ = dock_layout_; 141 initial_dock_layout_ = dock_layout_;
156 was_docked_ = GetAuraTarget()->parent() == dock_container; 142 was_docked_ = GetTarget()->GetParent() == dock_container;
157 is_docked_ = was_docked_; 143 is_docked_ = was_docked_;
158 } 144 }
159 145
160 void DockedWindowResizer::MaybeSnapToEdge(const gfx::Rect& bounds, 146 void DockedWindowResizer::MaybeSnapToEdge(const gfx::Rect& bounds,
161 gfx::Point* offset) { 147 gfx::Point* offset) {
162 // Windows only snap magnetically when they were previously docked. 148 // Windows only snap magnetically when they were previously docked.
163 if (!was_docked_) 149 if (!was_docked_)
164 return; 150 return;
165 DockedAlignment dock_alignment = dock_layout_->CalculateAlignment(); 151 DockedAlignment dock_alignment = dock_layout_->CalculateAlignment();
166 gfx::Rect dock_bounds = ScreenUtil::ConvertRectFromScreen( 152 gfx::Rect dock_bounds = GetTarget()->GetParent()->ConvertRectFromScreen(
167 GetAuraTarget()->parent(),
168 dock_layout_->dock_container()->GetBoundsInScreen()); 153 dock_layout_->dock_container()->GetBoundsInScreen());
169 154
170 // Short-range magnetism when retaining docked state. Same constant as in 155 // Short-range magnetism when retaining docked state. Same constant as in
171 // MagnetismMatcher is used for consistency. 156 // MagnetismMatcher is used for consistency.
172 const int kSnapToDockDistance = MagnetismMatcher::kMagneticDistance; 157 const int kSnapToDockDistance = MagnetismMatcher::kMagneticDistance;
173 158
174 if (dock_alignment == DOCKED_ALIGNMENT_LEFT || 159 if (dock_alignment == DOCKED_ALIGNMENT_LEFT ||
175 dock_alignment == DOCKED_ALIGNMENT_NONE) { 160 dock_alignment == DOCKED_ALIGNMENT_NONE) {
176 const int distance = bounds.x() - dock_bounds.x(); 161 const int distance = bounds.x() - dock_bounds.x();
177 if (distance < kSnapToDockDistance && distance > 0) { 162 if (distance < kSnapToDockDistance && distance > 0) {
(...skipping 19 matching lines...) Expand all
197 182
198 // Tell the dock layout manager that we are dragging this window. 183 // Tell the dock layout manager that we are dragging this window.
199 // At this point we are not yet animating the window as it may not be 184 // At this point we are not yet animating the window as it may not be
200 // inside the docked area. 185 // inside the docked area.
201 dock_layout_->StartDragging(GetAuraTarget()); 186 dock_layout_->StartDragging(GetAuraTarget());
202 if (!resizer) 187 if (!resizer)
203 return; 188 return;
204 // Reparent workspace windows during the drag to elevate them above workspace. 189 // Reparent workspace windows during the drag to elevate them above workspace.
205 // Other windows for which the DockedWindowResizer is instantiated include 190 // Other windows for which the DockedWindowResizer is instantiated include
206 // panels and windows that are already docked. Those do not need reparenting. 191 // panels and windows that are already docked. Those do not need reparenting.
207 if (GetAuraTarget()->type() != ui::wm::WINDOW_TYPE_PANEL && 192 if (GetTarget()->GetType() != ui::wm::WINDOW_TYPE_PANEL &&
208 GetAuraTarget()->parent()->id() == kShellWindowId_DefaultContainer) { 193 GetTarget()->GetParent()->GetShellWindowId() ==
194 kShellWindowId_DefaultContainer) {
209 // Reparent the window into the docked windows container in order to get it 195 // Reparent the window into the docked windows container in order to get it
210 // on top of other docked windows. 196 // on top of other docked windows.
211 aura::Window* docked_container = Shell::GetContainer( 197 wm::WmWindow* docked_container =
212 GetAuraTarget()->GetRootWindow(), kShellWindowId_DockedContainer); 198 GetTarget()->GetRootWindow()->GetChildByShellWindowId(
213 ReparentChildWithTransientChildren( 199 kShellWindowId_DockedContainer);
214 ash::wm::WmWindowAura::Get(GetAuraTarget()), 200 ReparentChildWithTransientChildren(GetTarget(), GetTarget()->GetParent(),
215 ash::wm::WmWindowAura::Get(GetAuraTarget()->parent()), 201 docked_container);
216 ash::wm::WmWindowAura::Get(docked_container));
217 if (!resizer) 202 if (!resizer)
218 return; 203 return;
219 } 204 }
220 if (is_docked_) 205 if (is_docked_)
221 dock_layout_->DockDraggedWindow(GetAuraTarget()); 206 dock_layout_->DockDraggedWindow(GetAuraTarget());
222 } 207 }
223 208
224 void DockedWindowResizer::FinishedDragging( 209 void DockedWindowResizer::FinishedDragging(
225 aura::client::WindowMoveResult move_result) { 210 aura::client::WindowMoveResult move_result) {
226 if (!did_move_or_resize_) 211 if (!did_move_or_resize_)
227 return; 212 return;
228 did_move_or_resize_ = false; 213 did_move_or_resize_ = false;
229 aura::Window* window = GetAuraTarget(); 214 wm::WmWindow* window = GetTarget();
230 const bool is_attached_panel = window->type() == ui::wm::WINDOW_TYPE_PANEL && 215 const bool is_attached_panel =
231 window_state_->panel_attached(); 216 window->GetType() == ui::wm::WINDOW_TYPE_PANEL &&
217 window_state_->panel_attached();
232 const bool is_resized = 218 const bool is_resized =
233 (details().bounds_change & WindowResizer::kBoundsChange_Resizes) != 0; 219 (details().bounds_change & WindowResizer::kBoundsChange_Resizes) != 0;
234 220
235 // Undock the window if it is not in the normal, docked or minimized state 221 // Undock the window if it is not in the normal, docked or minimized state
236 // type. This happens if a user snaps or maximizes a window using a 222 // type. This happens if a user snaps or maximizes a window using a
237 // keyboard shortcut while it is being dragged. 223 // keyboard shortcut while it is being dragged.
238 if (!window_state_->IsMinimized() && !window_state_->IsDocked() && 224 if (!window_state_->IsMinimized() && !window_state_->IsDocked() &&
239 !window_state_->IsNormalStateType()) 225 !window_state_->IsNormalStateType())
240 is_docked_ = false; 226 is_docked_ = false;
241 227
242 // When drag is completed the dragged docked window is resized to the bounds 228 // When drag is completed the dragged docked window is resized to the bounds
243 // calculated by the layout manager that conform to other docked windows. 229 // calculated by the layout manager that conform to other docked windows.
244 if (!is_attached_panel && is_docked_ && !is_resized) { 230 if (!is_attached_panel && is_docked_ && !is_resized) {
245 gfx::Rect bounds = ScreenUtil::ConvertRectFromScreen( 231 gfx::Rect bounds = window->GetParent()->ConvertRectFromScreen(
246 window->parent(), dock_layout_->dragged_bounds()); 232 dock_layout_->dragged_bounds());
247 if (!bounds.IsEmpty() && bounds.width() != window->bounds().width()) { 233 if (!bounds.IsEmpty() && bounds.width() != window->GetBounds().width()) {
248 window->SetBounds(bounds); 234 window->SetBounds(bounds);
249 } 235 }
250 } 236 }
251 // If a window has restore bounds, update the restore origin but not the size. 237 // If a window has restore bounds, update the restore origin but not the size.
252 // The size gets restored when a window is undocked. 238 // The size gets restored when a window is undocked.
253 if (is_resized && is_docked_ && window_state_->HasRestoreBounds()) { 239 if (is_resized && is_docked_ && window_state_->HasRestoreBounds()) {
254 gfx::Rect restore_bounds = window->GetBoundsInScreen(); 240 gfx::Rect restore_bounds = window->GetBoundsInScreen();
255 restore_bounds.set_size(window_state_->GetRestoreBoundsInScreen().size()); 241 restore_bounds.set_size(window_state_->GetRestoreBoundsInScreen().size());
256 window_state_->SetRestoreBoundsInScreen(restore_bounds); 242 window_state_->SetRestoreBoundsInScreen(restore_bounds);
257 } 243 }
(...skipping 12 matching lines...) Expand all
270 if (initial_dock_layout_ != dock_layout_) 256 if (initial_dock_layout_ != dock_layout_)
271 initial_dock_layout_->FinishDragging( 257 initial_dock_layout_->FinishDragging(
272 DOCKED_ACTION_NONE, 258 DOCKED_ACTION_NONE,
273 details().source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ? 259 details().source == aura::client::WINDOW_MOVE_SOURCE_MOUSE ?
274 DOCKED_ACTION_SOURCE_MOUSE : DOCKED_ACTION_SOURCE_TOUCH); 260 DOCKED_ACTION_SOURCE_MOUSE : DOCKED_ACTION_SOURCE_TOUCH);
275 is_docked_ = false; 261 is_docked_ = false;
276 } 262 }
277 263
278 DockedAction DockedWindowResizer::MaybeReparentWindowOnDragCompletion( 264 DockedAction DockedWindowResizer::MaybeReparentWindowOnDragCompletion(
279 bool is_resized, bool is_attached_panel) { 265 bool is_resized, bool is_attached_panel) {
280 aura::Window* window = GetAuraTarget(); 266 wm::WmWindow* window = GetTarget();
281 267
282 // Check if the window needs to be docked or returned to workspace. 268 // Check if the window needs to be docked or returned to workspace.
283 DockedAction action = DOCKED_ACTION_NONE; 269 DockedAction action = DOCKED_ACTION_NONE;
284 aura::Window* dock_container = Shell::GetContainer( 270 wm::WmWindow* dock_container =
285 window->GetRootWindow(), 271 window->GetRootWindow()->GetChildByShellWindowId(
286 kShellWindowId_DockedContainer); 272 kShellWindowId_DockedContainer);
287 if ((is_resized || !is_attached_panel) && 273 if ((is_resized || !is_attached_panel) &&
288 is_docked_ != (window->parent() == dock_container)) { 274 is_docked_ != (window->GetParent() == dock_container)) {
289 if (is_docked_) { 275 if (is_docked_) {
290 wm::ReparentChildWithTransientChildren( 276 wm::ReparentChildWithTransientChildren(window, window->GetParent(),
291 wm::WmWindowAura::Get(window), 277 dock_container);
292 wm::WmWindowAura::Get(window->parent()),
293 wm::WmWindowAura::Get(dock_container));
294 action = DOCKED_ACTION_DOCK; 278 action = DOCKED_ACTION_DOCK;
295 } else if (window->parent()->id() == kShellWindowId_DockedContainer) { 279 } else if (window->GetParent()->GetShellWindowId() ==
280 kShellWindowId_DockedContainer) {
296 // Reparent the window back to workspace. 281 // Reparent the window back to workspace.
297 // We need to be careful to give ParentWindowWithContext a location in 282 // We need to be careful to give ParentWindowWithContext a location in
298 // the right root window (matching the logic in DragWindowResizer) based 283 // the right root window (matching the logic in DragWindowResizer) based
299 // on which root window a mouse pointer is in. We want to undock into the 284 // on which root window a mouse pointer is in. We want to undock into the
300 // right screen near the edge of a multiscreen setup (based on where the 285 // right screen near the edge of a multiscreen setup (based on where the
301 // mouse is). 286 // mouse is).
302 gfx::Rect near_last_location(last_location_, gfx::Size()); 287 gfx::Rect near_last_location(last_location_, gfx::Size());
303 // Reparenting will cause Relayout and possible dock shrinking. 288 // Reparenting will cause Relayout and possible dock shrinking.
304 aura::Window* previous_parent = window->parent(); 289 wm::WmWindow* previous_parent = window->GetParent();
305 aura::client::ParentWindowWithContext(window, window, near_last_location); 290 window->SetParentUsingContext(window, near_last_location);
306 if (window->parent() != previous_parent) { 291 if (window->GetParent() != previous_parent) {
307 wm::ReparentTransientChildrenOfChild( 292 wm::ReparentTransientChildrenOfChild(window, previous_parent,
308 ash::wm::WmWindowAura::Get(window), 293 window->GetParent());
309 ash::wm::WmWindowAura::Get(previous_parent),
310 ash::wm::WmWindowAura::Get(window->parent()));
311 } 294 }
312 action = was_docked_ ? DOCKED_ACTION_UNDOCK : DOCKED_ACTION_NONE; 295 action = was_docked_ ? DOCKED_ACTION_UNDOCK : DOCKED_ACTION_NONE;
313 } 296 }
314 } else { 297 } else {
315 // |action| is recorded in UMA and used to maintain |window_state_|. 298 // |action| is recorded in UMA and used to maintain |window_state_|.
316 if (is_resized && is_docked_ && was_docked_) 299 if (is_resized && is_docked_ && was_docked_)
317 action = DOCKED_ACTION_RESIZE; 300 action = DOCKED_ACTION_RESIZE;
318 else if (is_docked_ && was_docked_) 301 else if (is_docked_ && was_docked_)
319 action = DOCKED_ACTION_REORDER; 302 action = DOCKED_ACTION_REORDER;
320 else if (is_docked_ && !was_docked_) 303 else if (is_docked_ && !was_docked_)
321 action = DOCKED_ACTION_DOCK; 304 action = DOCKED_ACTION_DOCK;
322 else if (!is_docked_ && was_docked_) 305 else if (!is_docked_ && was_docked_)
323 action = DOCKED_ACTION_UNDOCK; 306 action = DOCKED_ACTION_UNDOCK;
324 else 307 else
325 action = DOCKED_ACTION_NONE; 308 action = DOCKED_ACTION_NONE;
326 } 309 }
327 // When a window is newly docked it is auto-sized by docked layout adjusting 310 // When a window is newly docked it is auto-sized by docked layout adjusting
328 // to other windows. If it is just dragged (but not resized) while being 311 // to other windows. If it is just dragged (but not resized) while being
329 // docked it is auto-sized unless it has been resized while being docked 312 // docked it is auto-sized unless it has been resized while being docked
330 // before. 313 // before.
331 if (is_docked_) { 314 if (is_docked_) {
332 wm::GetWindowState(window)->set_bounds_changed_by_user( 315 window->GetWindowState()->set_bounds_changed_by_user(
333 was_docked_ && (is_resized || was_bounds_changed_by_user_)); 316 was_docked_ && (is_resized || was_bounds_changed_by_user_));
334 } 317 }
335 318
336 if (action == DOCKED_ACTION_DOCK) { 319 if (action == DOCKED_ACTION_DOCK) {
337 const wm::WMEvent event(wm::WM_EVENT_DOCK); 320 const wm::WMEvent event(wm::WM_EVENT_DOCK);
338 window_state_->OnWMEvent(&event); 321 window_state_->OnWMEvent(&event);
339 } else if (wm::GetWindowState(window)->IsDocked() && 322 } else if (window->GetWindowState()->IsDocked() &&
340 action == DOCKED_ACTION_UNDOCK) { 323 action == DOCKED_ACTION_UNDOCK) {
341 const wm::WMEvent event(wm::WM_EVENT_NORMAL); 324 const wm::WMEvent event(wm::WM_EVENT_NORMAL);
342 window_state_->OnWMEvent(&event); 325 window_state_->OnWMEvent(&event);
343 } 326 }
344 327
345 return action; 328 return action;
346 } 329 }
347 330
348 } // namespace ash 331 } // namespace ash
OLDNEW
« no previous file with comments | « ash/wm/dock/docked_window_resizer.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698