Remove OutputSurfaceClient external clip

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 571 matching lines @@
   EXPECT_TRUE(host_impl_->CanDraw());
   host_impl_->SetViewportSize(gfx::Size());
   EXPECT_FALSE(host_impl_->CanDraw());
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
   EXPECT_EQ(fake_output_surface->num_sent_frames(), 0u);
   gfx::Transform identity;
   gfx::Rect viewport(100, 100);
   const bool resourceless_software_draw = true;
-  host_impl_->OnDraw(identity, viewport, viewport, resourceless_software_draw);
+  host_impl_->OnDraw(identity, viewport, resourceless_software_draw);
   ASSERT_EQ(fake_output_surface->num_sent_frames(), 1u);
   EXPECT_EQ(gfx::SizeF(100.f, 100.f),
             fake_output_surface->last_sent_frame()->metadata.root_layer_size);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaNoLayers) {
   ASSERT_FALSE(host_impl_->active_tree()->root_layer_for_testing());
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info =
       host_impl_->ProcessScrollDeltas();
@@ skipping 3184 matching lines @@
   }
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawWhenDrawAndSwapFullViewportEveryFrame) {
   CreateHostImpl(DefaultSettings(),
                  FakeOutputSurface::CreateDelegatingSoftware());
 
   const gfx::Transform external_transform;
   const gfx::Rect external_viewport;
-  const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   std::vector<PrepareToDrawSuccessTestCase> cases;
 
   // 0. Default case.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   // 1. Animation with missing tile.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   cases.back().layer_between.has_missing_tile = true;
   cases.back().layer_between.is_animating = true;
   // 2. High res required with incomplete tile.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   cases.back().high_res_required = true;
   cases.back().layer_between.has_incomplete_tile = true;
   // 3. High res required with missing tile.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   cases.back().high_res_required = true;
   cases.back().layer_between.has_missing_tile = true;
 
   host_impl_->active_tree()->SetRootLayerForTesting(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
       host_impl_->active_tree()->root_layer_for_testing());
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
 
   for (size_t i = 0; i < cases.size(); ++i) {
     const auto& testcase = cases[i];
     std::vector<LayerImpl*> to_remove;
     for (auto* child : root->test_properties()->children)
       to_remove.push_back(child);
     for (auto* child : to_remove)
       root->test_properties()->RemoveChild(child);
 
     std::ostringstream scope;
     scope << "Test case: " << i;
     SCOPED_TRACE(scope.str());
 
     CreateLayerFromState(root, timeline(), testcase.layer_before);
     CreateLayerFromState(root, timeline(), testcase.layer_between);
     CreateLayerFromState(root, timeline(), testcase.layer_after);
     host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
     if (testcase.high_res_required)
       host_impl_->SetRequiresHighResToDraw();
 
-    host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+    host_impl_->OnDraw(external_transform, external_viewport,
                        resourceless_software_draw);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetScrollClipLayer(Layer::INVALID_ID);
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayerForTesting(std::move(root));
@@ skipping 2935 matching lines @@
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     VerifyEmptyLayerRenderPasses(frame.render_passes);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   void TestEmptyLayerWithOnDraw() {
     SetUpEmptylayer();
     gfx::Transform identity;
     gfx::Rect viewport(viewport_size_);
     bool resourceless_software_draw = true;
-    host_impl_->OnDraw(identity, viewport, viewport,
-                       resourceless_software_draw);
+    host_impl_->OnDraw(identity, viewport, resourceless_software_draw);
     VerifyEmptyLayerRenderPasses(last_on_draw_render_passes_);
   }
 
   // Expect four surrounding gutter rects.
   void SetUpLayerInMiddleOfViewport() {
     gfx::Rect layer_rect(500, 500, 200, 200);
     child_->SetPosition(gfx::PointF(layer_rect.origin()));
     child_->SetBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
@@ skipping 16 matching lines @@
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     VerifyLayerInMiddleOfViewport(frame.render_passes);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   void TestLayerInMiddleOfViewportWithOnDraw() {
     SetUpLayerInMiddleOfViewport();
     gfx::Transform identity;
     gfx::Rect viewport(viewport_size_);
     bool resourceless_software_draw = true;
-    host_impl_->OnDraw(identity, viewport, viewport,
-                       resourceless_software_draw);
+    host_impl_->OnDraw(identity, viewport, resourceless_software_draw);
     VerifyLayerInMiddleOfViewport(last_on_draw_render_passes_);
   }
 
   // Expect no gutter rects.
   void SetUpLayerIsLargerThanViewport() {
     gfx::Rect layer_rect(viewport_size_.width() + 10,
                          viewport_size_.height() + 10);
     child_->SetPosition(gfx::PointF(layer_rect.origin()));
     child_->SetBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
@@ skipping 15 matching lines @@
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     VerifyLayerIsLargerThanViewport(frame.render_passes);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   void TestLayerIsLargerThanViewportWithOnDraw() {
     SetUpLayerIsLargerThanViewport();
     gfx::Transform identity;
     gfx::Rect viewport(viewport_size_);
     bool resourceless_software_draw = true;
-    host_impl_->OnDraw(identity, viewport, viewport,
-                       resourceless_software_draw);
+    host_impl_->OnDraw(identity, viewport, resourceless_software_draw);
     VerifyLayerIsLargerThanViewport(last_on_draw_render_passes_);
   }
 
   void DidActivateSyncTree() override { did_activate_pending_tree_ = true; }
 
   void set_gutter_quad_material(DrawQuad::Material material) {
     gutter_quad_material_ = material;
   }
   void set_gutter_texture_size(const gfx::Size& gutter_texture_size) {
     gutter_texture_size_ = gutter_texture_size;
@@ skipping 710 matching lines @@
 };
 
 TEST_F(LayerTreeHostImplTest,
        ForcedDrawToSoftwareDeviceSkipsUnsupportedLayers) {
   set_reduce_memory_result(false);
   EXPECT_TRUE(CreateHostImpl(DefaultSettings(),
                              FakeOutputSurface::CreateDelegatingSoftware()));
 
   const gfx::Transform external_transform;
   const gfx::Rect external_viewport;
-  const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   // SolidColorLayerImpl will be drawn.
   std::unique_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
 
   // VideoLayerImpl will not be drawn.
   FakeVideoFrameProvider provider;
   std::unique_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 2, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
   root_layer->test_properties()->AddChild(std::move(video_layer));
   SetupRootLayerImpl(std::move(root_layer));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
 
   EXPECT_EQ(1u, last_on_draw_frame_->will_draw_layers.size());
   EXPECT_EQ(host_impl_->active_tree()->root_layer_for_testing(),
             last_on_draw_frame_->will_draw_layers[0]);
 }
 
 // Checks that we have a non-0 default allocation if we pass a context that
 // doesn't support memory management extensions.
 TEST_F(LayerTreeHostImplTest, DefaultMemoryAllocation) {
@@ skipping 1679 matching lines @@
   EXPECT_EQ(host_impl_->global_tile_state().hard_memory_limit_in_bytes,
             300u * 1024u * 1024u);
   EXPECT_EQ(host_impl_->global_tile_state().soft_memory_limit_in_bytes,
             150u * 1024u * 1024u);
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformReflectedInNextDraw) {
   const gfx::Size layer_size(100, 100);
   gfx::Transform external_transform;
   const gfx::Rect external_viewport(layer_size);
-  const gfx::Rect external_clip(layer_size);
   const bool resourceless_software_draw = false;
   LayerImpl* layer = SetupScrollAndContentsLayers(layer_size);
   layer->SetDrawsContent(true);
 
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       external_transform, layer->draw_properties().target_space_transform);
 
   external_transform.Translate(20, 20);
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       external_transform, layer->draw_properties().target_space_transform);
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformSetNeedsRedraw) {
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   const gfx::Transform transform_for_tile_priority;
   const gfx::Transform draw_transform;
   const gfx::Rect viewport_for_tile_priority1(viewport_size);
   const gfx::Rect viewport_for_tile_priority2(50, 50);
   const gfx::Rect draw_viewport(viewport_size);
-  const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
   // Clear any damage.
   host_impl_->SetExternalTilePriorityConstraints(viewport_for_tile_priority1,
                                                  transform_for_tile_priority);
-  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
-                     resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport, resourceless_software_draw);
   last_on_draw_frame_.reset();
 
   // Setting new constraints needs redraw.
   did_request_redraw_ = false;
   host_impl_->SetExternalTilePriorityConstraints(viewport_for_tile_priority2,
                                                  transform_for_tile_priority);
   EXPECT_TRUE(did_request_redraw_);
-  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
-                     resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport, resourceless_software_draw);
   EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
 }
 
 TEST_F(LayerTreeHostImplTest, OnDrawConstraintSetNeedsRedraw) {
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   const gfx::Transform draw_transform;
   const gfx::Rect draw_viewport1(viewport_size);
   const gfx::Rect draw_viewport2(50, 50);
-  const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
   // Clear any damage.
-  host_impl_->OnDraw(draw_transform, draw_viewport1, clip,
+  host_impl_->OnDraw(draw_transform, draw_viewport1,
                      resourceless_software_draw);
   last_on_draw_frame_.reset();
 
   // Same draw params does not swap.
   did_request_redraw_ = false;
-  host_impl_->OnDraw(draw_transform, draw_viewport1, clip,
+  host_impl_->OnDraw(draw_transform, draw_viewport1,
                      resourceless_software_draw);
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_TRUE(last_on_draw_frame_->has_no_damage);
   last_on_draw_frame_.reset();
 
   // Different draw params does swap.
   did_request_redraw_ = false;
-  host_impl_->OnDraw(draw_transform, draw_viewport2, clip,
+  host_impl_->OnDraw(draw_transform, draw_viewport2,
                      resourceless_software_draw);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
 }
 
 class ResourcelessSoftwareLayerTreeHostImplTest : public LayerTreeHostImplTest {
  protected:
   std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     return FakeOutputSurface::CreateDelegating3d();
   }
 };
 
 TEST_F(ResourcelessSoftwareLayerTreeHostImplTest,
        ResourcelessSoftwareSetNeedsRedraw) {
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   const gfx::Transform draw_transform;
   const gfx::Rect draw_viewport(viewport_size);
-  const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
   // Clear any damage.
-  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
-                     resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport, resourceless_software_draw);
   last_on_draw_frame_.reset();
 
   // Always swap even if same draw params.
   resourceless_software_draw = true;
-  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
-                     resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport, resourceless_software_draw);
   EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
   last_on_draw_frame_.reset();
 
   // Next hardware draw has damage.
   resourceless_software_draw = false;
-  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
-                     resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport, resourceless_software_draw);
   EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
 }
 
 TEST_F(ResourcelessSoftwareLayerTreeHostImplTest,
        ResourcelessSoftwareDrawSkipsUpdateTiles) {
   const gfx::Size viewport_size(100, 100);
   host_impl_->SetViewportSize(viewport_size);
 
   host_impl_->CreatePendingTree();
   scoped_refptr<FakeRasterSource> raster_source(
       FakeRasterSource::CreateFilled(viewport_size));
   std::unique_ptr<FakePictureLayerImpl> layer(
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_->pending_tree(),
                                                    11, raster_source));
   layer->SetBounds(viewport_size);
   layer->SetDrawsContent(true);
   host_impl_->pending_tree()->SetRootLayerForTesting(std::move(layer));
 
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
   host_impl_->ActivateSyncTree();
 
   const gfx::Transform draw_transform;
   const gfx::Rect draw_viewport(viewport_size);
-  const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
   // Regular draw causes UpdateTiles.
   did_request_prepare_tiles_ = false;
-  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
-                     resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport, resourceless_software_draw);
   EXPECT_TRUE(did_request_prepare_tiles_);
   host_impl_->PrepareTiles();
 
   // Resourceless draw skips UpdateTiles.
   const gfx::Rect new_draw_viewport(50, 50);
   resourceless_software_draw = true;
   did_request_prepare_tiles_ = false;
-  host_impl_->OnDraw(draw_transform, new_draw_viewport, clip,
+  host_impl_->OnDraw(draw_transform, new_draw_viewport,
                      resourceless_software_draw);
   EXPECT_FALSE(did_request_prepare_tiles_);
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTileConstraintReflectedInPendingTree) {
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
   const gfx::Size layer_size(100, 100);
   host_impl_->SetViewportSize(layer_size);
   bool update_lcd_text = false;
 
@@ skipping 34 matching lines @@
                                  ->children[0];
 
   bool update_lcd_text = false;
 
   host_impl_->SetViewportSize(gfx::Size(90, 90));
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
   EXPECT_EQ(gfx::Rect(90, 90), content_layer->visible_layer_rect());
 
   gfx::Transform external_transform;
   gfx::Rect external_viewport(10, 20);
-  gfx::Rect external_clip(layer_size);
   bool resourceless_software_draw = false;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(10, 20), content_layer->visible_layer_rect());
 
   // Clear the external viewport.
   external_viewport = gfx::Rect();
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(90, 90), content_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsVisibleRects) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
   LayerImpl* content_layer = host_impl_->active_tree()
                                  ->OuterViewportScrollLayer()
                                  ->test_properties()
                                  ->children[0];
 
   bool update_lcd_text = false;
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
   EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect());
 
   gfx::Transform external_transform;
   external_transform.Translate(10, 10);
   external_transform.Scale(2, 2);
   gfx::Rect external_viewport;
-  gfx::Rect external_clip(layer_size);
   bool resourceless_software_draw = false;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   // Visible rects should now be shifted and scaled because of the external
   // transform.
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(20, 20), content_layer->visible_layer_rect());
 
   // Clear the external transform.
   external_transform = gfx::Transform();
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
   LayerImpl* content_layer = host_impl_->active_tree()
                                  ->OuterViewportScrollLayer()
                                  ->test_properties()
@@ skipping 15 matching lines @@
   host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
   TransformNode* node =
       host_impl_->active_tree()->property_trees()->transform_tree.Node(
           test_layer->transform_tree_index());
   EXPECT_EQ(node->surface_contents_scale, gfx::Vector2dF(1.f, 1.f));
 
   gfx::Transform external_transform;
   external_transform.Translate(10, 10);
   external_transform.Scale(2, 2);
   gfx::Rect external_viewport;
-  gfx::Rect external_clip(layer_size);
   bool resourceless_software_draw = false;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   // Transform node's sublayer scale should include the device transform scale.
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   node = host_impl_->active_tree()->property_trees()->transform_tree.Node(
       test_layer->transform_tree_index());
   EXPECT_EQ(node->surface_contents_scale, gfx::Vector2dF(2.f, 2.f));
 
   // Clear the external transform.
   external_transform = gfx::Transform();
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+  host_impl_->OnDraw(external_transform, external_viewport,
                      resourceless_software_draw);
   node = host_impl_->active_tree()->property_trees()->transform_tree.Node(
       test_layer->transform_tree_index());
   EXPECT_EQ(node->surface_contents_scale, gfx::Vector2dF(1.f, 1.f));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollAnimated) {
   const gfx::Size content_size(1000, 1000);
   const gfx::Size viewport_size(50, 100);
   CreateBasicVirtualViewportLayers(viewport_size, content_size);
@@ skipping 1155 matching lines @@
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Re-initialize with a software output surface.
   output_surface_ = FakeOutputSurface::CreateDelegatingSoftware();
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc