cc: Moving anti-aliasing decision to parent compositor.

cc/delegated_renderer_layer_impl_unittest.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/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/quad_sink.h"
@@ skipping 455 matching lines @@
     delegated_renderer_layer->setBounds(gfx::Size(30, 30)); 
     delegated_renderer_layer->setContentBounds(gfx::Size(30, 30));
     delegated_renderer_layer->setDrawsContent(true);
     gfx::Transform transform;
     transform.Scale(2.0, 2.0);
     transform.Translate(8.0, 8.0);
     delegated_renderer_layer->setTransform(transform);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
+    gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     child_pass_transform.Scale(0.8, 0.8);
     child_pass_transform.Translate(9.0, 9.0);
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
 
     {
       TestRenderPass* pass = addRenderPass(
           delegated_render_passes,
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
       MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
       AppendQuadsData data(pass->id);
       SharedQuadState* shared_quad_state = quad_sink.useSharedQuadState(
           SharedQuadState::Create());
       shared_quad_state->SetAll(
           child_pass_transform,
+          child_pass_content_bounds,
           child_pass_rect,
           child_pass_clip_rect,
           child_pass_clipped,
           1.f);
 
       scoped_ptr<SolidColorDrawQuad> color_quad;
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u);
       quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
 
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
       quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
     }
 
+    gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     root_pass_transform.Scale(1.5, 1.5);
     root_pass_transform.Translate(7.0, 7.0);
     gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
     TestRenderPass* pass = addRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
     MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state = quad_sink.useSharedQuadState(SharedQuadState::Create());
     shared_quad_state->SetAll(
         root_pass_transform,
+        root_pass_content_bounds,
         root_pass_rect,
         root_pass_clip_rect,
         root_pass_clipped,
         1.f);
 
     scoped_ptr<RenderPassDrawQuad> render_pass_quad =
         RenderPassDrawQuad::Create();
     render_pass_quad->SetNew(
         shared_quad_state,
         gfx::Rect(5, 5, 7, 7),  // rect
@@ skipping 315 matching lines @@
         DelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
     scoped_ptr<LayerImpl> clip_layer =
         LayerImpl::create(host_impl_->activeTree(), 3);
     scoped_ptr<LayerImpl> origin_layer =
         LayerImpl::create(host_impl_->activeTree(), 4);
 
     host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     root_layer->setBounds(gfx::Size(100, 100));
 
     delegated_renderer_layer->setPosition(gfx::Point(20, 20));
-    delegated_renderer_layer->setBounds(gfx::Size(50, 50)); 
+    delegated_renderer_layer->setBounds(gfx::Size(50, 50));
     delegated_renderer_layer->setContentBounds(gfx::Size(50, 50));
     delegated_renderer_layer->setDrawsContent(true);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
+    gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
 
     {
       TestRenderPass* pass = addRenderPass(
           delegated_render_passes,
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
       MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
       AppendQuadsData data(pass->id);
       SharedQuadState* shared_quad_state =
           quad_sink.useSharedQuadState(SharedQuadState::Create());
       shared_quad_state->SetAll(
           child_pass_transform,
+          child_pass_content_bounds,
           child_pass_rect,
           child_pass_clip_rect,
           child_pass_clipped,
           1.f);
 
       scoped_ptr<SolidColorDrawQuad> color_quad;
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u);
       quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
 
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
       quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
     }
 
+    gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
     TestRenderPass* pass = addRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
     MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state =
         quad_sink.useSharedQuadState(SharedQuadState::Create());
-    shared_quad_state->SetAll(root_pass_transform, root_pass_rect, root_pass_clip_rect, root_pass_clipped, 1);
+    shared_quad_state->SetAll(root_pass_transform,
+                              root_pass_content_bounds,
+                              root_pass_rect,
+                              root_pass_clip_rect,
+                              root_pass_clipped,
+                              1.f);
 
     scoped_ptr<RenderPassDrawQuad> render_pass_quad =
         RenderPassDrawQuad::Create();
     render_pass_quad->SetNew(
         shared_quad_state,
         gfx::Rect(5, 5, 7, 7),  // rect
         RenderPass::Id(10, 7),  // render_pass_id
         false,  // is_replica
         0,  // mask_resource_id
         child_pass_rect,  // contents_changed_since_last_frame
@@ skipping 301 matching lines @@
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->drawLayers(frame);
   host_impl_->didDrawAllLayers(frame);
 }
 
 }  // namespace
 }  // namespace cc