Update from chromium https://crrev.com/302282

cc/surfaces/surface_aggregator.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/surfaces/surface_aggregator.h"
 
+#include <map>
+
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
@@ skipping 115 matching lines @@
 
   typedef ResourceProvider::ResourceIdArray IdArray;
   IdArray referenced_resources;
 
   bool invalid_frame = false;
   DrawQuad::ResourceIteratorCallback remap =
       base::Bind(&ResourceRemapHelper,
                  &invalid_frame,
                  provider_->GetChildToParentMap(child_id),
                  &referenced_resources);
-  for (auto* render_pass : *render_pass_list) {
-    for (auto& quad : render_pass->quad_list)
-      quad.IterateResources(remap);
+  for (const auto& render_pass : *render_pass_list) {
+    for (const auto& quad : render_pass->quad_list)
+      quad->IterateResources(remap);
   }
 
   if (!invalid_frame)
     provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
 
   return invalid_frame;
 }
 
 gfx::Rect SurfaceAggregator::DamageRectForSurface(const Surface* surface,
                                                   const RenderPass& source) {
@@ skipping 143 matching lines @@
     const QuadList& source_quad_list,
     const SharedQuadStateList& source_shared_quad_state_list,
     const gfx::Transform& content_to_target_transform,
     RenderPass* dest_pass,
     SurfaceId surface_id) {
   const SharedQuadState* last_copied_source_shared_quad_state = NULL;
 
   SharedQuadStateList::ConstIterator sqs_iter =
       source_shared_quad_state_list.begin();
   for (const auto& quad : source_quad_list) {
-    while (quad.shared_quad_state != &*sqs_iter) {
+    while (quad->shared_quad_state != *sqs_iter) {
       ++sqs_iter;
       DCHECK(sqs_iter != source_shared_quad_state_list.end());
     }
-    DCHECK_EQ(quad.shared_quad_state, &*sqs_iter);
+    DCHECK_EQ(quad->shared_quad_state, *sqs_iter);
 
-    if (quad.material == DrawQuad::SURFACE_CONTENT) {
-      const SurfaceDrawQuad* surface_quad =
-          SurfaceDrawQuad::MaterialCast(&quad);
+    if (quad->material == DrawQuad::SURFACE_CONTENT) {
+      const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
       HandleSurfaceQuad(surface_quad, dest_pass);
     } else {
-      if (quad.shared_quad_state != last_copied_source_shared_quad_state) {
+      if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
         CopySharedQuadState(
-            quad.shared_quad_state, content_to_target_transform, dest_pass);
-        last_copied_source_shared_quad_state = quad.shared_quad_state;
+            quad->shared_quad_state, content_to_target_transform, dest_pass);
+        last_copied_source_shared_quad_state = quad->shared_quad_state;
       }
-      if (quad.material == DrawQuad::RENDER_PASS) {
+      if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
-            RenderPassDrawQuad::MaterialCast(&quad);
+            RenderPassDrawQuad::MaterialCast(quad);
         RenderPassId original_pass_id = pass_quad->render_pass_id;
         RenderPassId remapped_pass_id =
             RemapPassId(original_pass_id, surface_id);
 
         dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad,
             dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
       } else {
         dest_pass->CopyFromAndAppendDrawQuad(
-            &quad, dest_pass->shared_quad_state_list.back());
+            quad, dest_pass->shared_quad_state_list.back());
       }
     }
   }
 }
 
 void SurfaceAggregator::CopyPasses(const DelegatedFrameData* frame_data,
                                    Surface* surface) {
   RenderPassList source_pass_list;
 
   // The root surface is allowed to have copy output requests, so grab them
@@ skipping 68 matching lines @@
       surface->TakeLatencyInfo(&frame->metadata.latency_info);
   }
 
   // TODO(jamesr): Aggregate all resource references into the returned frame's
   // resource list.
 
   return frame.Pass();
 }
 
 }  // namespace cc