Update from https://crrev.com/320931

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"
@@ skipping 210 matching lines @@
       request.second->SendEmptyResult();
       delete request.second;
     }
     return;
   }
 
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
 
   bool merge_pass = surface_quad->opacity() == 1.f && copy_requests.empty();
 
+  gfx::Rect surface_damage = DamageRectForSurface(
+      surface, *render_pass_list.back(), surface_quad->visible_rect);
   const RenderPassList& referenced_passes = render_pass_list;
   size_t passes_to_copy =
       merge_pass ? referenced_passes.size() - 1 : referenced_passes.size();
   for (size_t j = 0; j < passes_to_copy; ++j) {
     const RenderPass& source = *referenced_passes[j];
 
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
     RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
-    copy_pass->SetAll(remapped_pass_id,
-                      source.output_rect,
-                      source.damage_rect,
+    copy_pass->SetAll(remapped_pass_id, source.output_rect, gfx::Rect(),
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     // Contributing passes aggregated in to the pass list need to take the
     // transform of the surface quad into account to update their transform to
     // the root surface.
     copy_pass->transform_to_root_target.ConcatTransform(
         surface_quad->quadTransform());
     copy_pass->transform_to_root_target.ConcatTransform(
         content_to_target_transform);
     copy_pass->transform_to_root_target.ConcatTransform(
         dest_pass->transform_to_root_target);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     gfx::Transform(), ClipData(), copy_pass.get(), surface_id);
 
+    if (j == referenced_passes.size() - 1)
+      surface_damage = gfx::UnionRects(surface_damage, copy_pass->damage_rect);
+
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 
   const RenderPass& last_pass = *render_pass_list.back();
   if (merge_pass) {
     // TODO(jamesr): Clean up last pass special casing.
     const QuadList& quads = last_pass.quad_list;
 
     gfx::Transform surface_transform = surface_quad->quadTransform();
     surface_transform.ConcatTransform(content_to_target_transform);
@@ skipping 28 matching lines @@
                  0,
                  gfx::Vector2dF(),
                  gfx::Size(),
                  FilterOperations(),
                  gfx::Vector2dF(),
                  FilterOperations());
   }
   dest_pass->damage_rect =
       gfx::UnionRects(dest_pass->damage_rect,
                       MathUtil::MapEnclosingClippedRect(
-                          surface_quad->quadTransform(),
-                          DamageRectForSurface(surface, last_pass,
-                                               surface_quad->visible_rect)));
+                          surface_quad->quadTransform(), surface_damage));
 
   referenced_surfaces_.erase(it);
 }
 
 void SurfaceAggregator::CopySharedQuadState(
     const SharedQuadState* source_sqs,
     const gfx::Transform& content_to_target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_render_pass) {
   SharedQuadState* copy_shared_quad_state =
@@ skipping 43 matching lines @@
                             content_to_target_transform, clip_rect, dest_pass);
         last_copied_source_shared_quad_state = quad->shared_quad_state;
       }
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_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(),
+        gfx::Rect pass_damage;
+        for (const auto* pass : *dest_pass_list_) {
+          if (pass->id == remapped_pass_id) {
+            pass_damage = pass->damage_rect;
+            break;
+          }
+        }
+
+        DrawQuad* rpdq = dest_pass->CopyFromAndAppendRenderPassDrawQuad(
+            pass_quad, dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
+        dest_pass->damage_rect = gfx::UnionRects(
+            dest_pass->damage_rect, MathUtil::MapEnclosingClippedRect(
+                                        rpdq->quadTransform(), pass_damage));
       } else {
         dest_pass->CopyFromAndAppendDrawQuad(
             quad, dest_pass->shared_quad_state_list.back());
       }
     }
   }
 }
 
 void SurfaceAggregator::CopyPasses(const DelegatedFrameData* frame_data,
                                    Surface* surface) {
@@ skipping 12 matching lines @@
 
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     RenderPassId remapped_pass_id =
         RemapPassId(source.id, surface->surface_id());
 
-    copy_pass->SetAll(remapped_pass_id, source.output_rect,
-                      DamageRectForSurface(surface, source, source.output_rect),
+    gfx::Rect damage_rect =
+        (i < source_pass_list.size() - 1)
+            ? gfx::Rect()
+            : DamageRectForSurface(surface, source, source.output_rect);
+    copy_pass->SetAll(remapped_pass_id, source.output_rect, damage_rect,
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     gfx::Transform(), ClipData(), copy_pass.get(),
                     surface->surface_id());
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 }
@@ skipping 64 matching lines @@
 void SurfaceAggregator::ReleaseResources(SurfaceId surface_id) {
   SurfaceToResourceChildIdMap::iterator it =
       surface_id_to_resource_child_id_.find(surface_id);
   if (it != surface_id_to_resource_child_id_.end()) {
     provider_->DestroyChild(it->second);
     surface_id_to_resource_child_id_.erase(it);
   }
 }
 
 }  // namespace cc