Snap widgets to pixel boundary on ash

ash/root_window_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/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/ash_constants.h"
@@ skipping 838 matching lines @@
     lock_background_container->AddChild(mouse_event_target_.get());
     mouse_event_target_->Show();
   }
 
   // Create Docked windows layout manager
   aura::Window* docked_container = GetContainer(kShellWindowId_DockedContainer);
   docked_layout_manager_ =
       new DockedWindowLayoutManager(docked_container, workspace_controller());
   docked_container->SetLayoutManager(docked_layout_manager_);
 
+  // Installs SnapLayoutManager to containers who set the
+  // |kSnapsChildrenToPhysicalPixelBoundary| property.
+  wm::InstallSnapLayoutManagerToContainers(root_window);
+

[Jun Mukai, 2014/07/16 22:59:08]

Not sure why this is necessary.  Instead of setting the property below, why not
just setting the SnapToPixelLayoutManager there?

[oshima, 2014/07/17 22:07:56]

Because some containers may install its own layout managers, and I wanted to
keep it more declarative. (I will change CreateContainer to
take bitmap flags that specifies, this , screen coordinates, animation and so
forth, but in separate CL)

I can be convinced the other way though.

[Jun Mukai, 2014/07/17 22:26:31]

Hmm, I don't get the point.

If a container with the snap-to-pixel property installs its own layout manager,
the layout manager implementation should respect the property, or inherit
SnapToPixelLayoutManager. Otherwise, the property is just ignored. Right?

Then, the declaration doesn't help the situation so much. The implementers need
to care about SnapToPixelLayoutManager anyways.

How about this:
- keep this class and InstallSnapLayoutManagerToContainers().
  This class is solely responsible for the SnapToPixel property setups.
- in ctor of SnapToPixelLayoutManager, don't set property. Instead, add a DCHECK
to verify if the declarations (i.e. this class) is correct.

[Jun Mukai, 2014/07/17 22:27:16]

ah, your new patchset is in this way. Thanks for quick work.

[oshima, 2014/07/17 22:28:40]

Sorry, I should have mentioned that.

   // Create Panel layout manager
   aura::Window* panel_container = GetContainer(kShellWindowId_PanelContainer);
   panel_layout_manager_ = new PanelLayoutManager(panel_container);
   panel_container->SetLayoutManager(panel_layout_manager_);
   panel_container_handler_.reset(new PanelWindowEventHandler);
   panel_container->AddPreTargetHandler(panel_container_handler_.get());
 
   // Install an AttachedPanelWindowTargeter on the panel container to make it
   // easier to correctly target shelf buttons with touch.
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize,
@@ skipping 108 matching lines @@
       CreateContainer(kShellWindowId_ShelfContainer,
                       "ShelfContainer",
                       non_lock_screen_containers);
   SetUsesScreenCoordinates(shelf_container);
   DescendantShouldStayInSameRootWindow(shelf_container);
 
   aura::Window* panel_container = CreateContainer(
       kShellWindowId_PanelContainer,
       "PanelContainer",
       non_lock_screen_containers);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(panel_container);
   SetUsesScreenCoordinates(panel_container);
 
   aura::Window* shelf_bubble_container =
       CreateContainer(kShellWindowId_ShelfBubbleContainer,
                       "ShelfBubbleContainer",
                       non_lock_screen_containers);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(shelf_bubble_container);
   SetUsesScreenCoordinates(shelf_bubble_container);
   DescendantShouldStayInSameRootWindow(shelf_bubble_container);
 
   aura::Window* app_list_container =
       CreateContainer(kShellWindowId_AppListContainer,
                       "AppListContainer",
                       non_lock_screen_containers);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(app_list_container);
   SetUsesScreenCoordinates(app_list_container);
 
   aura::Window* modal_container = CreateContainer(
       kShellWindowId_SystemModalContainer,
       "SystemModalContainer",
       non_lock_screen_containers);
   modal_container->SetLayoutManager(
       new SystemModalContainerLayoutManager(modal_container));
   ::wm::SetChildWindowVisibilityChangesAnimated(modal_container);
   SetUsesScreenCoordinates(modal_container);
@@ skipping 30 matching lines @@
                       "StatusContainer",
                       lock_screen_related_containers);
   SetUsesScreenCoordinates(status_container);
   DescendantShouldStayInSameRootWindow(status_container);
 
   aura::Window* settings_bubble_container = CreateContainer(
       kShellWindowId_SettingBubbleContainer,
       "SettingBubbleContainer",
       lock_screen_related_containers);
   ::wm::SetChildWindowVisibilityChangesAnimated(settings_bubble_container);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(settings_bubble_container);
   SetUsesScreenCoordinates(settings_bubble_container);
   DescendantShouldStayInSameRootWindow(settings_bubble_container);
 
   aura::Window* menu_container = CreateContainer(
       kShellWindowId_MenuContainer,
       "MenuContainer",
       lock_screen_related_containers);
   ::wm::SetChildWindowVisibilityChangesAnimated(menu_container);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(menu_container);
   SetUsesScreenCoordinates(menu_container);
 
   aura::Window* drag_drop_container = CreateContainer(
       kShellWindowId_DragImageAndTooltipContainer,
       "DragImageAndTooltipContainer",
       lock_screen_related_containers);
   ::wm::SetChildWindowVisibilityChangesAnimated(drag_drop_container);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(drag_drop_container);
   SetUsesScreenCoordinates(drag_drop_container);
 
   aura::Window* overlay_container = CreateContainer(
       kShellWindowId_OverlayContainer,
       "OverlayContainer",
       lock_screen_related_containers);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(overlay_container);
   SetUsesScreenCoordinates(overlay_container);
 
   aura::Window* virtual_keyboard_parent_container = CreateContainer(
       kShellWindowId_VirtualKeyboardParentContainer,
       "VirtualKeyboardParentContainer",
       root_window);
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(
+      virtual_keyboard_parent_container);
   SetUsesScreenCoordinates(virtual_keyboard_parent_container);
 
 #if defined(OS_CHROMEOS)
   aura::Window* mouse_cursor_container = CreateContainer(
       kShellWindowId_MouseCursorContainer,
       "MouseCursorContainer",
       root_window);
   SetUsesScreenCoordinates(mouse_cursor_container);
 #endif
 
@@ skipping 23 matching lines @@
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(
     const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : NULL;
 }
 
 }  // namespace ash