Update from https://crrev.com/308996

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 30 matching lines @@
 }  // namespace
 
 SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
                                      ResourceProvider* provider)
     : manager_(manager), provider_(provider), next_render_pass_id_(1) {
   DCHECK(manager_);
 }
 
 SurfaceAggregator::~SurfaceAggregator() {}
 
+// Create a clip rect for an aggregated quad from the original clip rect and
+// the clip rect from the surface it's on.
+SurfaceAggregator::ClipData SurfaceAggregator::CalculateClipRect(
+    const ClipData& surface_clip,
+    const ClipData& quad_clip,
+    const gfx::Transform& content_to_target_transform) {
+  ClipData out_clip;
+  if (surface_clip.is_clipped)
+    out_clip = surface_clip;
+
+  if (quad_clip.is_clipped) {
+    // TODO(jamesr): This only works if content_to_target_transform maps integer
+    // rects to integer rects.
+    gfx::Rect final_clip = MathUtil::MapEnclosingClippedRect(
+        content_to_target_transform, quad_clip.rect);
+    if (out_clip.is_clipped)
+      out_clip.rect.Intersect(final_clip);
+    else
+      out_clip.rect = final_clip;
+    out_clip.is_clipped = true;
+  }
+
+  return out_clip;
+}
+
 class SurfaceAggregator::RenderPassIdAllocator {
  public:
   explicit RenderPassIdAllocator(int* next_index) : next_index_(next_index) {}
   ~RenderPassIdAllocator() {}
 
   void AddKnownPass(RenderPassId id) {
     if (id_to_index_map_.find(id) != id_to_index_map_.end())
       return;
     id_to_index_map_[id] = (*next_index_)++;
   }
@@ skipping 95 matching lines @@
                                                   const RenderPass& source,
                                                   const gfx::Rect& full_rect) {
   int previous_index = previous_contained_surfaces_[surface->surface_id()];
   if (previous_index == surface->frame_index())
     return gfx::Rect();
   else if (previous_index == surface->frame_index() - 1)
     return source.damage_rect;
   return full_rect;
 }
 
-void SurfaceAggregator::HandleSurfaceQuad(const SurfaceDrawQuad* surface_quad,
-                                          float opacity,
-                                          RenderPass* dest_pass) {
+void SurfaceAggregator::HandleSurfaceQuad(
+    const SurfaceDrawQuad* surface_quad,
+    const gfx::Transform& content_to_target_transform,
+    const ClipData& clip_rect,
+    RenderPass* dest_pass) {
   SurfaceId surface_id = surface_quad->surface_id;
   // If this surface's id is already in our referenced set then it creates
   // a cycle in the graph and should be dropped.
   if (referenced_surfaces_.count(surface_id))
     return;
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   if (!surface) {
     contained_surfaces_[surface_id] = 0;
     return;
   }
@@ skipping 13 matching lines @@
   if (invalid_frame) {
     for (auto& request : copy_requests) {
       request.second->SendEmptyResult();
       delete request.second;
     }
     return;
   }
 
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
 
-  bool merge_pass = copy_requests.empty();
+  bool merge_pass = surface_quad->opacity() == 1.f && copy_requests.empty();
 
   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,
                       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.
     // TODO(jamesr): Make sure this is sufficient for surfaces nested several
     // levels deep and add tests.
     copy_pass->transform_to_root_target.ConcatTransform(
         surface_quad->quadTransform());
+    copy_pass->transform_to_root_target.ConcatTransform(
+        content_to_target_transform);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
-                    gfx::Transform(), 1.f, copy_pass.get(), surface_id);
+                    gfx::Transform(), ClipData(), copy_pass.get(), surface_id);
 
     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;
 
-    // TODO(jamesr): Make sure clipping is enforced.
-    CopyQuadsToPass(quads, last_pass.shared_quad_state_list,
-                    surface_quad->quadTransform(),
-                    surface_quad->opacity() * opacity, dest_pass, surface_id);
+    gfx::Transform surface_transform = surface_quad->quadTransform();
+    surface_transform.ConcatTransform(content_to_target_transform);
+
+    // Intersect the transformed visible rect and the clip rect to create a
+    // smaller cliprect for the quad.
+    ClipData surface_quad_clip_rect(
+        true, MathUtil::MapEnclosingClippedRect(surface_quad->quadTransform(),
+                                                surface_quad->visible_rect));
+    if (surface_quad->isClipped())
+      surface_quad_clip_rect.rect.Intersect(surface_quad->clipRect());
+
+    ClipData quads_clip = CalculateClipRect(clip_rect, surface_quad_clip_rect,
+                                            content_to_target_transform);
+
+    CopyQuadsToPass(quads, last_pass.shared_quad_state_list, surface_transform,
+                    quads_clip, dest_pass, surface_id);
   } else {
     RenderPassId remapped_pass_id = RemapPassId(last_pass.id, surface_id);
 
+    CopySharedQuadState(surface_quad->shared_quad_state,
+                        content_to_target_transform, clip_rect, dest_pass);
+
     SharedQuadState* shared_quad_state =
-        dest_pass->CreateAndAppendSharedQuadState();
-    shared_quad_state->CopyFrom(surface_quad->shared_quad_state);
-    shared_quad_state->opacity *= opacity;
+        dest_pass->shared_quad_state_list.back();
     RenderPassDrawQuad* quad =
         dest_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     quad->SetNew(shared_quad_state,
                  surface_quad->rect,
                  surface_quad->visible_rect,
                  remapped_pass_id,
                  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)));
 
   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 =
       dest_render_pass->CreateAndAppendSharedQuadState();
   copy_shared_quad_state->CopyFrom(source_sqs);
   // content_to_target_transform contains any transformation that may exist
   // between the context that these quads are being copied from (i.e. the
   // surface's draw transform when aggregated from within a surface) to the
   // target space of the pass. This will be identity except when copying the
   // root draw pass from a surface into a pass when the surface draw quad's
   // transform is not identity.
   copy_shared_quad_state->content_to_target_transform.ConcatTransform(
       content_to_target_transform);
-  if (copy_shared_quad_state->is_clipped) {
-    copy_shared_quad_state->clip_rect = MathUtil::MapEnclosingClippedRect(
-        content_to_target_transform, copy_shared_quad_state->clip_rect);
-  }
+
+  ClipData new_clip_rect = CalculateClipRect(
+      clip_rect, ClipData(source_sqs->is_clipped, source_sqs->clip_rect),
+      content_to_target_transform);
+  copy_shared_quad_state->is_clipped = new_clip_rect.is_clipped;
+  copy_shared_quad_state->clip_rect = new_clip_rect.rect;
 }
 
 void SurfaceAggregator::CopyQuadsToPass(
     const QuadList& source_quad_list,
     const SharedQuadStateList& source_shared_quad_state_list,
     const gfx::Transform& content_to_target_transform,
-    float opacity,
+    const ClipData& clip_rect,
     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) {
       ++sqs_iter;
       DCHECK(sqs_iter != source_shared_quad_state_list.end());
     }
     DCHECK_EQ(quad->shared_quad_state, *sqs_iter);
 
     if (quad->material == DrawQuad::SURFACE_CONTENT) {
       const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
-      HandleSurfaceQuad(surface_quad, opacity, dest_pass);
+      HandleSurfaceQuad(surface_quad, content_to_target_transform, clip_rect,
+                        dest_pass);
     } else {
       if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
-        CopySharedQuadState(
-            quad->shared_quad_state, content_to_target_transform, dest_pass);
-        dest_pass->shared_quad_state_list.back()->opacity *= opacity;
+        CopySharedQuadState(quad->shared_quad_state,
+                            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(
@@ skipping 31 matching lines @@
 
     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),
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
-                    gfx::Transform(), 1.f, copy_pass.get(),
+                    gfx::Transform(), ClipData(), copy_pass.get(),
                     surface->surface_id());
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 }
 
 void SurfaceAggregator::RemoveUnreferencedChildren() {
   for (const auto& surface : previous_contained_surfaces_) {
     if (!contained_surfaces_.count(surface.first)) {
       SurfaceToResourceChildIdMap::iterator it =
@@ skipping 55 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