Invert DSF to map from delegated frame to layer space

cc/layers/delegated_renderer_layer_impl.cc

 // Copyright 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 "cc/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 128 matching lines @@
 
   // Declare we are using the new frame's resources.
   resources_.swap(resources_in_frame);
   resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
 
   // 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(1.0 / layer_tree_impl()->device_scale_factor());

[enne (OOO), 2014/06/05 23:02:14]

nit: 1.0 => 1.f, here and elsewhere.  I don't think you're intending to do the
division as a double and convert back to float?

   SetUpdateRect(gfx::IntersectRects(
       gfx::UnionRects(update_rect(), damage_in_layer), gfx::Rect(bounds())));
 
   SetRenderPasses(&render_pass_list);
   have_render_passes_to_push_ = true;
 }
 
 void DelegatedRendererLayerImpl::SetDisplaySize(const gfx::Size& size) {
   if (display_size_ == size)
     return;
@@ skipping 28 matching lines @@
     LayerTreeImpl* tree_impl) {
   return DelegatedRendererLayerImpl::Create(
       tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::ReleaseResources() {
   ClearRenderPasses();
   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; }
 
 RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId()
     const {
   return RenderPass::Id(id(), IndexToId(0));
 }
 
 RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
     RenderPass::Id previous) const {
@@ skipping 15 matching lines @@
   return true;
 }
 
 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
     RenderPassSink* render_pass_sink) {
   DCHECK(HasContributingDelegatedRenderPasses());
 
   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();
+  double inverse_device_scale_factor =

[enne (OOO), 2014/06/05 23:02:14]

Transforms are all floats.  Is double intentional here?

+      1.0 / layer_tree_impl()->device_scale_factor();
+  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);
     bool present =
         ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id,
                                      &output_render_pass_id);
 
     // Don't clash with the RenderPass we generate if we own a RenderSurface.
     DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", "
                     << render_passes_in_draw_order_[i]->id.index;
@@ skipping 151 matching lines @@
       delegated_shared_quad_state = delegated_quad->shared_quad_state;
       output_shared_quad_state = quad_sink->CreateSharedQuadState();
       output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
 
       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();
+        double inverse_device_scale_factor =
+            1.0 / layer_tree_impl()->device_scale_factor();
+        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);
 
         if (render_target() == this) {
           DCHECK(!is_clipped());
           DCHECK(render_surface());
           DCHECK_EQ(0, num_unclipped_descendants());
           output_shared_quad_state->clip_rect =
               MathUtil::MapEnclosingClippedRect(
@@ skipping 63 matching lines @@
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc