Scale the ALPHA_THRESHOLD filter's region based on the device scale factor.

ui/compositor/layer.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 "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 316 matching lines @@
 }
 
 void Layer::SetBackgroundZoom(float zoom, int inset) {
   zoom_ = zoom;
   zoom_inset_ = inset;
 
   SetLayerBackgroundFilters();
 }
 
 void Layer::SetAlphaShape(scoped_ptr<SkRegion> region) {
-  alpha_shape_ = region.Pass();
+  dips_alpha_shape_ = region.Pass();
+  RecomputeAlphaShape();
 
   SetLayerFilters();
 }
 
 void Layer::SetLayerFilters() {
   cc::FilterOperations filters;
   if (layer_saturation_) {
     filters.Append(cc::FilterOperation::CreateSaturateFilter(
         layer_saturation_));
   }
@@ skipping 266 matching lines @@
 }
 
 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
   if (animator_.get())
     animator_->StopAnimatingProperty(LayerAnimationElement::TRANSFORM);
   device_scale_factor_ = device_scale_factor;
   RecomputeDrawsContentAndUVRect();
   RecomputePosition();
+  RecomputeAlphaShape();
   SchedulePaint(gfx::Rect(bounds_.size()));
   if (delegate_)
     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->OnDeviceScaleFactorChanged(device_scale_factor);
   if (layer_mask_)
     layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 void Layer::RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request) {
@@ skipping 289 matching lines @@
     size.SetToMin(frame_size_in_dip_);
     delegated_renderer_layer_->SetDisplaySize(frame_size_in_dip_);
   }
   cc_layer_->SetBounds(size);
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::PointF(bounds_.x(), bounds_.y()));
 }
 
+void Layer::RecomputeAlphaShape() {
+  if (dips_alpha_shape_) {
+    // Scale the region by the device_scale_factor to properly handle
+    // HiDPI devices. Since there is no SkRegion scaling, we convert to
+    // a path, scale the path and then convert back to a SkRegion.

[danakj, 2014/06/09 22:21:39]

:/ Storing 2 regions now, regions are costly, so I'm not excited about that.
Would it work to just add a scale to the FilterOperation, and make use of that
scale when applying the region to the alpha channel?

[garykac, 2014/07/10 23:02:23]

Acknowledged.

+    SkPath path;
+    dips_alpha_shape_->getBoundaryPath(&path);
+    SkMatrix scale;
+    scale.setScale(device_scale_factor_, device_scale_factor_);
+    path.transform(scale);
+    SkRegion clip;
+    clip.setRect(0, 0, bounds_.width(), bounds_.height());
+
+    alpha_shape_->setPath(path, clip);
+  }
+}
+
 }  // namespace ui