Update from https://crrev.com/320343

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
@@ skipping 921 matching lines @@
     middle_pass_list.swap(middle_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> middle_frame(new CompositorFrame);
     middle_frame->delegated_frame_data = middle_frame_data.Pass();
 
     factory_.SubmitFrame(middle_surface_id, middle_frame.Pass(),
                          SurfaceFactory::DrawCallback());
   }
 
   // Root surface.
-  test::Quad root_quads[] = {test::Quad::SolidColorQuad(1),
-                             test::Quad::SurfaceQuad(middle_surface_id, 1.f)};
-  test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
+  test::Quad secondary_quads[] = {
+      test::Quad::SolidColorQuad(1),
+      test::Quad::SurfaceQuad(middle_surface_id, 1.f)};
+  test::Quad root_quads[] = {test::Quad::SolidColorQuad(1)};
+  test::Pass root_passes[] = {
+      test::Pass(secondary_quads, arraysize(secondary_quads)),
+      test::Pass(root_quads, arraysize(root_quads))};
 
   RenderPassList root_pass_list;
   AddPasses(&root_pass_list,
             gfx::Rect(SurfaceSize()),
             root_passes,
             arraysize(root_passes));
 
   root_pass_list.at(0)
       ->shared_quad_state_list.front()
       ->content_to_target_transform.Translate(0, 7);
   root_pass_list.at(0)
       ->shared_quad_state_list.ElementAt(1)
       ->content_to_target_transform.Translate(0, 10);
   root_pass_list.at(0)->quad_list.ElementAt(1)->visible_rect =
       gfx::Rect(0, 0, 8, 100);
 
+  root_pass_list[0]->transform_to_root_target.Translate(10, 5);
+
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
 
   factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
                        SurfaceFactory::DrawCallback());
 
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
-  ASSERT_EQ(2u, aggregated_pass_list.size());
+  ASSERT_EQ(3u, aggregated_pass_list.size());
 
   ASSERT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
 
   // The first pass should have one shared quad state for the one solid color
   // quad.
   EXPECT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
-  // The second (root) pass should have just two shared quad states. We'll
+  // The second pass should have just two shared quad states. We'll
   // verify the properties through the quads.
   EXPECT_EQ(2u, aggregated_pass_list[1]->shared_quad_state_list.size());
 
+  EXPECT_EQ(1u, aggregated_pass_list[2]->shared_quad_state_list.size());
+
   SharedQuadState* aggregated_first_pass_sqs =
       aggregated_pass_list[0]->shared_quad_state_list.front();
 
   // The first pass's transform should be unaffected by the embedding and still
   // be a translation by +5 in the x direction.
   gfx::Transform expected_aggregated_first_pass_sqs_transform;
   expected_aggregated_first_pass_sqs_transform.Translate(5, 0);
   EXPECT_EQ(expected_aggregated_first_pass_sqs_transform.ToString(),
             aggregated_first_pass_sqs->content_to_target_transform.ToString());
 
   // The first pass's transform to the root target should include the aggregated
-  // transform.
+  // transform, including the transform from the child pass to the root.
   gfx::Transform expected_first_pass_transform_to_root_target;
+  expected_first_pass_transform_to_root_target.Translate(10, 5);
   expected_first_pass_transform_to_root_target.Translate(0, 10);
   expected_first_pass_transform_to_root_target.Scale(2, 3);
   expected_first_pass_transform_to_root_target.Translate(8, 0);
   EXPECT_EQ(expected_first_pass_transform_to_root_target.ToString(),
             aggregated_pass_list[0]->transform_to_root_target.ToString());
 
   ASSERT_EQ(2u, aggregated_pass_list[1]->quad_list.size());
 
   gfx::Transform expected_root_pass_quad_transforms[2];
   // The first quad in the root pass is the solid color quad from the original
@@ skipping 392 matching lines @@
   EXPECT_THAT(returned_ids,
               testing::WhenSorted(testing::ElementsAreArray(ids)));
   EXPECT_EQ(3u, resource_provider_->num_resources());
   factory.Destroy(surface_id);
   factory.Destroy(surface_id2);
 }
 
 }  // namespace
 }  // namespace cc