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() {
+  if (!layer())
+    return;
+
+  if (snap_layer_to_pixel_boundary_ && layer()->parent() &&
+      layer()->GetCompositor()) {
+    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 928 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_ =
+      (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 500 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