Snap layers in views to physical pixel

ui/views/view.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/compositor/compositor.h"
+#include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/scoped_canvas.h"
@@ skipping 72 matching lines @@
       id_(0),
       group_(-1),
       parent_(NULL),
       visible_(true),
       enabled_(true),
       notify_enter_exit_on_child_(false),
       registered_for_visible_bounds_notification_(false),
       root_bounds_dirty_(true),
       clip_insets_(0, 0, 0, 0),
       needs_layout_(true),
+      snap_layer_to_pixel_boundary_(false),
       flip_canvas_on_paint_for_rtl_ui_(false),
       paint_to_layer_(false),
       accelerator_focus_manager_(NULL),
       registered_accelerator_count_(0),
       next_focusable_view_(NULL),
       previous_focusable_view_(NULL),
       focusable_(false),
       accessibility_focusable_(false),
       context_menu_controller_(NULL),
       drag_controller_(NULL),
@@ skipping 440 matching lines @@
 
 void View::SetLayoutManager(LayoutManager* layout_manager) {
   if (layout_manager_.get())
     layout_manager_->Uninstalled(this);
 
   layout_manager_.reset(layout_manager);
   if (layout_manager_.get())
     layout_manager_->Installed(this);
 }
 
+void View::SnapLayerToPixelBoundary() {

[Ben Goodger (Google), 2014/07/08 16:07:34]

should this be implemented in Layer?

[oshima, 2014/07/08 17:39:18]

Layer currently does not know which layers are aligned (this CL assumes that
widgets are aligned). I can add a flag to layer (to enable or disable depending
on the default), that's one option. Or I can define
Layer::SnapToPixelBoundary(ui::Layer* aligned_layer) and let caller decide which
layers are aligned.

ben@, danakj@, what do you think? Let me know if you have a better idea, and I'm
happy to change.

+  if (!layer())
+    return;
+
+  if (snap_layer_to_pixel_boundary_ &&
+      layer()->parent() && layer()->GetCompositor()) {

[danakj, 2014/07/15 21:11:02]

why the check for GetCompositor?

[oshima, 2014/07/15 22:28:42]

Because view can exist without parent nor widget.
It gets recomputed when (re)attached in OnDeviceScaleFactorChanged.

+    ui::SnapLayerToPhysicalPixelBoundary(layer()->parent(), layer());
+  } else {
+    // Reset the offset.
+    layer()->SetSubpixelPositionOffset(gfx::Vector2dF());
+  }
+}
+
 // Attributes ------------------------------------------------------------------
 
 const char* View::GetClassName() const {
   return kViewClassName;
 }
 
 const View* View::GetAncestorWithClassName(const std::string& name) const {
   for (const View* view = this; view; view = view->parent_) {
     if (!strcmp(view->GetClassName(), name.c_str()))
       return view;
@@ skipping 950 matching lines @@
   }
 }
 
 void View::OnPaintLayer(gfx::Canvas* canvas) {
   if (!layer() || !layer()->fills_bounds_opaquely())
     canvas->DrawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
   PaintCommon(canvas, CullSet());
 }
 
 void View::OnDeviceScaleFactorChanged(float device_scale_factor) {
+  snap_layer_to_pixel_boundary_ =

[danakj, 2014/07/15 21:11:02]

Didn't you want this to be false for some layers like shadows?

[oshima, 2014/07/15 22:28:42]

Yes, it'll be handled in a separate CL for ash. (shadow is in ash, not views)

+      (device_scale_factor - std::floor(device_scale_factor)) != 0.0f;
+  SnapLayerToPixelBoundary();
   // Repainting with new scale factor will paint the content at the right scale.
 }
 
 base::Closure View::PrepareForLayerBoundsChange() {
   return base::Closure();
 }
 
 void View::ReorderLayers() {
   View* v = this;
   while (v && !v->layer())
@@ skipping 509 matching lines @@
   Views::iterator i(std::find(
       descendants_to_notify_->begin(), descendants_to_notify_->end(), view));
   DCHECK(i != descendants_to_notify_->end());
   descendants_to_notify_->erase(i);
   if (descendants_to_notify_->empty())
     descendants_to_notify_.reset();
 }
 
 void View::SetLayerBounds(const gfx::Rect& bounds) {
   layer()->SetBounds(bounds);
+  SnapLayerToPixelBoundary();
 }
 
 void View::SetRootBoundsDirty(bool origin_changed) {
   root_bounds_dirty_ = true;
 
   if (origin_changed) {
     // Inform our children that their root bounds are dirty, as their relative
     // coordinates in paint root space have changed since ours have changed.
     for (Views::const_iterator i(children_.begin()); i != children_.end();
          ++i) {
@@ skipping 422 matching lines @@
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views