cc: Apply occlusion before creating quads in RenderSurfaceImpl.

cc/layers/render_surface_impl.cc

 // Copyright 2011 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/render_surface_impl.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 125 matching lines @@
 }
 
 void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
                                     AppendQuadsData* append_quads_data,
                                     bool for_replica,
                                     RenderPass::Id render_pass_id) {
   DCHECK(!for_replica || owning_layer_->has_replica());
 
   const gfx::Transform& draw_transform =
       for_replica ? replica_draw_transform_ : draw_transform_;
+  gfx::Rect visible_content_rect =
+      quad_sink->UnoccludedContentRect(content_rect_, draw_transform);

[enne (OOO), 2014/03/19 23:05:32]

Why does this not use UnoccludedContributingSurfaceContentRect? That's what
MaybeAppend would have done, I thought?

[danakj, 2014/03/19 23:12:33]

Cuz copy/paste, woops. Maybe I should add a separate occlusion rect in the
MockQuadCuller for this method?

[enne (OOO), 2014/03/19 23:18:36]

Yah.  Having a test that would have caught this sgtm.

[danakj, 2014/03/19 23:22:22]

Done.

+  if (visible_content_rect.IsEmpty())
+    return;
+
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(SharedQuadState::Create());
   shared_quad_state->SetAll(draw_transform,
                             content_rect_.size(),
                             content_rect_,
                             clip_rect_,
                             is_clipped_,
                             draw_opacity_,
                             owning_layer_->blend_mode());
 
   if (owning_layer_->ShowDebugBorders()) {
-    gfx::Rect quad_rect = content_rect_;
-    gfx::Rect visible_quad_rect = quad_rect;
     SkColor color = for_replica ?
                     DebugColors::SurfaceReplicaBorderColor() :
                     DebugColors::SurfaceBorderColor();
     float width = for_replica ?
                   DebugColors::SurfaceReplicaBorderWidth(
                       owning_layer_->layer_tree_impl()) :
                   DebugColors::SurfaceBorderWidth(
                       owning_layer_->layer_tree_impl());
     scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
         DebugBorderDrawQuad::Create();
     debug_border_quad->SetNew(
-        shared_quad_state, quad_rect, visible_quad_rect, color, width);
-    quad_sink->MaybeAppend(debug_border_quad.PassAs<DrawQuad>());
+        shared_quad_state, content_rect_, visible_content_rect, color, width);
+    quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
   }
 
   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
   // and its reflection, it's currently not possible to apply a separate mask to
   // the reflection layer or correctly handle opacity in reflections (opacity
   // must be applied after drawing both the layer and its reflection). The
   // solution is to introduce yet another RenderSurfaceImpl to draw the layer
   // and its reflection in. For now we only apply a separate reflection mask if
   // the contents don't have a mask of their own.
   LayerImpl* mask_layer = owning_layer_->mask_layer();
@@ skipping 23 matching lines @@
     float uv_scale_y =
         content_rect_.height() / unclipped_mask_target_size.height();
 
     mask_uv_rect = gfx::RectF(
         uv_scale_x * content_rect_.x() / content_rect_.width(),
         uv_scale_y * content_rect_.y() / content_rect_.height(),
         uv_scale_x,
         uv_scale_y);
   }
 
-  gfx::Rect visible_content_rect(content_rect_);
   ResourceProvider::ResourceId mask_resource_id =
       mask_layer ? mask_layer->ContentsResourceId() : 0;
   gfx::Rect contents_changed_since_last_frame =
       ContentsChanged() ? content_rect_ : gfx::Rect();
 
   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                content_rect_,
                visible_content_rect,
                render_pass_id,
                for_replica,
                mask_resource_id,
                contents_changed_since_last_frame,
                mask_uv_rect,
                owning_layer_->filters(),
                owning_layer_->background_filters());
-  quad_sink->MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink->Append(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc