Invert DSF to map from delegated frame to layer space

cc/layers/delegated_renderer_layer_impl.cc

Index: cc/layers/delegated_renderer_layer_impl.cc
diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index f59e1f2c1da785613c631d44f316f7a555519c35..c1cdbbe4194a924bafda5e442c898d3583c564cf 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -20,10 +20,11 @@
 
 namespace cc {
 
-DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(
-    LayerTreeImpl* tree_impl, int id)
+DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(LayerTreeImpl* tree_impl,
+                                                       int id)
     : LayerImpl(tree_impl, id),
       have_render_passes_to_push_(false),
+      inverse_device_scale_factor_(1.0f),
       child_id_(0),
       own_child_id_(false) {
 }
@@ -75,7 +76,6 @@ void DelegatedRendererLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   delegated_layer->own_child_id_ = true;
   own_child_id_ = false;
 
-  delegated_layer->SetDisplaySize(display_size_);
   if (have_render_passes_to_push_) {
     // This passes ownership of the render passes to the active tree.
     delegated_layer->SetRenderPasses(&render_passes_in_draw_order_);
@@ -141,13 +141,14 @@ void DelegatedRendererLayerImpl::SetFrameData(
   resources_.swap(resources_in_frame);
   resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
 
+  inverse_device_scale_factor_ = 1.0f / frame_data->device_scale_factor;
   // Display size is already set so we can compute what the damage rect
   // will be in layer space. The damage may exceed the visible portion of
   // the frame, so intersect the damage to the layer's bounds.
   RenderPass* new_root_pass = render_pass_list.back();
   gfx::Size frame_size = new_root_pass->output_rect.size();
-  gfx::RectF damage_in_layer = MathUtil::MapClippedRect(
-      DelegatedFrameToLayerSpaceTransform(frame_size), damage_in_frame);
+  gfx::RectF damage_in_layer = damage_in_frame;
+  damage_in_layer.Scale(inverse_device_scale_factor_);
   SetUpdateRect(gfx::IntersectRects(
       gfx::UnionRects(update_rect(), damage_in_layer), gfx::Rect(bounds())));
 
@@ -155,13 +156,6 @@ void DelegatedRendererLayerImpl::SetFrameData(
   have_render_passes_to_push_ = true;
 }
 
-void DelegatedRendererLayerImpl::SetDisplaySize(const gfx::Size& size) {
-  if (display_size_ == size)
-    return;
-  display_size_ = size;
-  NoteLayerPropertyChanged();
-}
-
 void DelegatedRendererLayerImpl::SetRenderPasses(
     ScopedPtrVector<RenderPass>* render_passes_in_draw_order) {
   ClearRenderPasses();
@@ -196,17 +190,6 @@ void DelegatedRendererLayerImpl::ReleaseResources() {
   ClearChildId();
 }
 
-gfx::Transform DelegatedRendererLayerImpl::DelegatedFrameToLayerSpaceTransform(
-    const gfx::Size& frame_size) const {
-  gfx::Size display_size = display_size_.IsEmpty() ? bounds() : display_size_;
-
-  gfx::Transform delegated_frame_to_layer_space_transform;
-  delegated_frame_to_layer_space_transform.Scale(
-      static_cast<double>(display_size.width()) / frame_size.width(),
-      static_cast<double>(display_size.height()) / frame_size.height());
-  return delegated_frame_to_layer_space_transform;
-}
-
 static inline int IndexToId(int index) { return index + 1; }
 static inline int IdToIndex(int id) { return id - 1; }
 
@@ -242,9 +225,9 @@ void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
-  gfx::Transform delegated_frame_to_root_transform =
-      screen_space_transform() *
-      DelegatedFrameToLayerSpaceTransform(frame_size);
+  gfx::Transform delegated_frame_to_root_transform = screen_space_transform();
+  delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_,
+                                          inverse_device_scale_factor_);
 
   for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
     RenderPass::Id output_render_pass_id(-1, -1);
@@ -413,11 +396,9 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
       bool is_root_delegated_render_pass =
           delegated_render_pass == render_passes_in_draw_order_.back();
       if (is_root_delegated_render_pass) {
-        // Don't allow areas inside the bounds that are empty.
-        DCHECK(display_size_.IsEmpty() ||
-               gfx::Rect(display_size_).Contains(gfx::Rect(bounds())));
-        gfx::Transform delegated_frame_to_target_transform =
-            draw_transform() * DelegatedFrameToLayerSpaceTransform(frame_size);
+        gfx::Transform delegated_frame_to_target_transform = draw_transform();
+        delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
+                                                  inverse_device_scale_factor_);
 
         output_shared_quad_state->content_to_target_transform.ConcatTransform(
             delegated_frame_to_target_transform);