cc: Use the size of the source frame along with the source frame's renderpasses

cc/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/delegated_renderer_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
@@ skipping 17 matching lines @@
 }
 
 bool DelegatedRendererLayerImpl::hasContributingDelegatedRenderPasses() const
 {
     // The root RenderPass for the layer is merged with its target
     // RenderPass in each frame. So we only have extra RenderPasses
     // to merge when we have a non-root RenderPass present.
     return m_renderPassesInDrawOrder.size() > 1;
 }
 
-void DelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<RenderPass>& renderPassesInDrawOrder)
+void DelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<RenderPass>& renderPassesInDrawOrder, gfx::Size frameSize)
 {
     gfx::RectF oldRootDamage;
     if (!m_renderPassesInDrawOrder.isEmpty())
         oldRootDamage = m_renderPassesInDrawOrder.last()->damage_rect;
 
     clearRenderPasses();
 
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
         m_renderPassesIndexById.insert(std::pair<RenderPass::Id, int>(renderPassesInDrawOrder[i]->id, i));
         m_renderPassesInDrawOrder.append(renderPassesInDrawOrder.take(i));
     }
     renderPassesInDrawOrder.clear();
 
     if (!m_renderPassesInDrawOrder.isEmpty())
         m_renderPassesInDrawOrder.last()->damage_rect.Union(oldRootDamage);
+
+    m_frameSize = frameSize;
 }
 
 void DelegatedRendererLayerImpl::clearRenderPasses()
 {
     // FIXME: Release the resources back to the nested compositor.
     m_renderPassesIndexById.clear();
     m_renderPassesInDrawOrder.clear();
 }
 
 void DelegatedRendererLayerImpl::didLoseOutputSurface()
@@ skipping 74 matching lines @@
         if (quad->shared_quad_state != currentSharedQuadState) {
             currentSharedQuadState = quad->shared_quad_state;
             copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->Copy());
             bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layer_id == id();
             if (!targetIsFromDelegatedRendererLayer) {
               // Should be the root render pass.
               DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.last());
               // This layer must be drawing to a renderTarget other than itself.
               DCHECK(renderTarget() != this);
 
-              copiedSharedQuadState->content_to_target_transform = drawTransform() * copiedSharedQuadState->content_to_target_transform;
+              gfx::Transform delegatedFrameToLayerSpaceTransform;
+              delegatedFrameToLayerSpaceTransform.Scale(
+                  static_cast<double>(m_frameSize.width()) / bounds().width(),
+                  static_cast<double>(m_frameSize.height()) / bounds().height());
+
+              copiedSharedQuadState->content_to_target_transform = drawTransform() * delegatedFrameToLayerSpaceTransform * copiedSharedQuadState->content_to_target_transform;
               copiedSharedQuadState->clipped_rect_in_target = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clipped_rect_in_target);
               copiedSharedQuadState->clip_rect = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clip_rect);
               copiedSharedQuadState->opacity *= drawOpacity();
             }
         }
         DCHECK(copiedSharedQuadState);
 
         scoped_ptr<DrawQuad> copyQuad;
         if (quad->material != DrawQuad::RENDER_PASS)
             copyQuad = quad->Copy(copiedSharedQuadState);
         else {
             RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::MaterialCast(quad)->render_pass_id;
             RenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
             DCHECK(contributingRenderPassId != appendQuadsData.renderPassId);
 
             copyQuad = RenderPassDrawQuad::MaterialCast(quad)->Copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
         }
         DCHECK(copyQuad.get());
 
         quadSink.append(copyQuad.Pass(), appendQuadsData);
     }
 }
 
 const char* DelegatedRendererLayerImpl::layerTypeAsString() const
 {
     return "DelegatedRendererLayer";
 }
 
 }  // namespace cc