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

cc/layers/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/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 107 matching lines @@
   RenderPassList render_pass_list;
   RenderPass::CopyAll(frame_data->render_pass_list, &render_pass_list);
 
   bool invalid_frame = false;
   ResourceProvider::ResourceIdArray resources_in_frame;
   DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
       base::Bind(&ResourceRemapHelper,
                  &invalid_frame,
                  resource_map,
                  &resources_in_frame);
-  for (size_t i = 0; i < render_pass_list.size(); ++i) {
-    RenderPass* pass = render_pass_list[i];
-    for (auto& quad : pass->quad_list)
-      quad.IterateResources(remap_resources_to_parent_callback);
+  for (const auto& pass : render_pass_list) {
+    for (const auto& quad : pass->quad_list)
+      quad->IterateResources(remap_resources_to_parent_callback);
   }
 
   if (invalid_frame) {
     // Declare we are still using the last frame's resources.
     resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
     return;
   }
 
   // Declare we are using the new frame's resources.
   resources_.swap(resources_in_frame);
@@ skipping 247 matching lines @@
     AppendQuadsData* append_quads_data,
     const RenderPass* delegated_render_pass,
     const gfx::Size& frame_size) const {
   const SharedQuadState* delegated_shared_quad_state = nullptr;
   SharedQuadState* output_shared_quad_state = nullptr;
 
   for (const auto& delegated_quad : delegated_render_pass->quad_list) {
     bool is_root_delegated_render_pass =
         delegated_render_pass == render_passes_in_draw_order_.back();
 
-    if (delegated_quad.shared_quad_state != delegated_shared_quad_state) {
-      delegated_shared_quad_state = delegated_quad.shared_quad_state;
+    if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
+      delegated_shared_quad_state = delegated_quad->shared_quad_state;
       output_shared_quad_state = render_pass->CreateAndAppendSharedQuadState();
       output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
 
       if (is_root_delegated_render_pass) {
         gfx::Transform delegated_frame_to_target_transform = draw_transform();
         delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
                                                   inverse_device_scale_factor_);
 
         output_shared_quad_state->content_to_target_transform.ConcatTransform(
             delegated_frame_to_target_transform);
@@ skipping 29 matching lines @@
           delegated_render_pass->transform_to_root_target);
       quad_content_to_delegated_target_space.ConcatTransform(draw_transform());
     }
 
     Occlusion occlusion_in_quad_space =
         occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
             quad_content_to_delegated_target_space);
 
     gfx::Rect quad_visible_rect =
         occlusion_in_quad_space.GetUnoccludedContentRect(
-            delegated_quad.visible_rect);
+            delegated_quad->visible_rect);
 
     if (quad_visible_rect.IsEmpty())
       continue;
 
-    if (delegated_quad.material != DrawQuad::RENDER_PASS) {
+    if (delegated_quad->material != DrawQuad::RENDER_PASS) {
       DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad(
-          &delegated_quad, output_shared_quad_state);
+          delegated_quad, output_shared_quad_state);
       output_quad->visible_rect = quad_visible_rect;
     } else {
       RenderPassId delegated_contributing_render_pass_id =
-          RenderPassDrawQuad::MaterialCast(&delegated_quad)->render_pass_id;
+          RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id;
       RenderPassId output_contributing_render_pass_id(-1, -1);
 
       bool present =
           ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id,
                                        &output_contributing_render_pass_id);
 
       // The frame may have a RenderPassDrawQuad that points to a RenderPass not
       // part of the frame. Just ignore these quads.
       if (present) {
         DCHECK(output_contributing_render_pass_id !=
                append_quads_data->render_pass_id);
 
         RenderPassDrawQuad* output_quad =
             render_pass->CopyFromAndAppendRenderPassDrawQuad(
-                RenderPassDrawQuad::MaterialCast(&delegated_quad),
+                RenderPassDrawQuad::MaterialCast(delegated_quad),
                 output_shared_quad_state,
                 output_contributing_render_pass_id);
         output_quad->visible_rect = quad_visible_rect;
       }
     }
   }
 }
 
 const char* DelegatedRendererLayerImpl::LayerTypeAsString() const {
   return "cc::DelegatedRendererLayerImpl";
 }
 
 void DelegatedRendererLayerImpl::ClearChildId() {
   if (!child_id_)
     return;
 
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc