cc: Pass Occlusion instead of OcclusionTracker to LayerImpls

This patch updates LayerImpls to accept Occlusion into AppendQuads
instead of OcclusionTracker. This makes it possible for the layer
to retain a local copy for whatever reason, and restricts the code
from modifying occlusion information in unexpected ways.

R=danakj

Review URL: https://codereview.chromium.org/633773004

Cr-Commit-Position: refs/heads/master@{#298556}

35 files changed, 132 insertions, 190 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index c7c6468..7cd4430 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -16,7 +16,7 @@
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 
 namespace cc {
 
@@ -254,7 +254,7 @@ bool DelegatedRendererLayerImpl::WillDraw(DrawMode draw_mode,
 
 void DelegatedRendererLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   AppendRainbowDebugBorder(render_pass, append_quads_data);
 
@@ -281,7 +281,7 @@ void DelegatedRendererLayerImpl::AppendQuads(
     DCHECK(target_render_pass_id.layer_id == render_target()->id());
 
     AppendRenderPassQuads(render_pass,
-                          occlusion_tracker,
+                          occlusion_in_content_space,
                           append_quads_data,
                           root_delegated_render_pass,
                           frame_size);
@@ -293,7 +293,7 @@ void DelegatedRendererLayerImpl::AppendQuads(
     const RenderPass* delegated_render_pass =
         render_passes_in_draw_order_[render_pass_index];
     AppendRenderPassQuads(render_pass,
-                          occlusion_tracker,
+                          occlusion_in_content_space,
                           append_quads_data,
                           delegated_render_pass,
                           frame_size);
@@ -383,7 +383,7 @@ void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
 
 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data,
     const RenderPass* delegated_render_pass,
     const gfx::Size& frame_size) const {
@@ -439,10 +439,13 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
       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_tracker.GetCurrentOcclusionForLayer(
-                              quad_content_to_delegated_target_space)
-            .GetUnoccludedContentRect(delegated_quad.visible_rect);
+        occlusion_in_quad_space.GetUnoccludedContentRect(
+            delegated_quad.visible_rect);
 
     if (quad_visible_rect.IsEmpty())
       continue;
diff --git a/cc/layers/delegated_renderer_layer_impl.h b/cc/layers/delegated_renderer_layer_impl.h
index db63928..53f2f8a 100644
--- a/cc/layers/delegated_renderer_layer_impl.h
+++ b/cc/layers/delegated_renderer_layer_impl.h
@@ -35,7 +35,7 @@ class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
   virtual void PushPropertiesTo(LayerImpl* layer) override;
 
@@ -78,12 +78,11 @@ class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
   bool ConvertDelegatedRenderPassId(RenderPassId delegated_render_pass_id,
                                     RenderPassId* output_render_pass_id) const;
 
-  void AppendRenderPassQuads(
-      RenderPass* render_pass,
-      const OcclusionTracker<LayerImpl>& occlusion_tracker,
-      AppendQuadsData* append_quads_data,
-      const RenderPass* delegated_render_pass,
-      const gfx::Size& frame_size) const;
+  void AppendRenderPassQuads(RenderPass* render_pass,
+                             const Occlusion& occlusion_in_content_space,
+                             AppendQuadsData* append_quads_data,
+                             const RenderPass* delegated_render_pass,
+                             const gfx::Size& frame_size) const;
 
   // LayerImpl overrides.
   virtual const char* LayerTypeAsString() const override;
diff --git a/cc/layers/heads_up_display_layer_impl.cc b/cc/layers/heads_up_display_layer_impl.cc
index 7272725..ecf1dc6 100644
--- a/cc/layers/heads_up_display_layer_impl.cc
+++ b/cc/layers/heads_up_display_layer_impl.cc
@@ -131,7 +131,7 @@ bool HeadsUpDisplayLayerImpl::WillDraw(DrawMode draw_mode,
 
 void HeadsUpDisplayLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   if (!resources_.back()->id())
     return;
diff --git a/cc/layers/heads_up_display_layer_impl.h b/cc/layers/heads_up_display_layer_impl.h
index fc5fbe7..388dfcd 100644
--- a/cc/layers/heads_up_display_layer_impl.h
+++ b/cc/layers/heads_up_display_layer_impl.h
@@ -40,7 +40,7 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
   void UpdateHudTexture(DrawMode draw_mode,
                         ResourceProvider* resource_provider);
diff --git a/cc/layers/heads_up_display_layer_impl_unittest.cc b/cc/layers/heads_up_display_layer_impl_unittest.cc
index 828a93a..d342d4f 100644
--- a/cc/layers/heads_up_display_layer_impl_unittest.cc
+++ b/cc/layers/heads_up_display_layer_impl_unittest.cc
@@ -7,7 +7,6 @@
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
-#include "cc/test/mock_occlusion_tracker.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -17,12 +16,11 @@ namespace {
 void CheckDrawLayer(HeadsUpDisplayLayerImpl* layer,
                     ResourceProvider* resource_provider,
                     DrawMode draw_mode) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   bool will_draw = layer->WillDraw(draw_mode, resource_provider);
   if (will_draw)
-    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer->AppendQuads(render_pass.get(), Occlusion(), &data);
   layer->UpdateHudTexture(draw_mode, resource_provider);
   if (will_draw)
     layer->DidDraw(resource_provider);
diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 7cb86ce..8d22195 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -9,7 +9,7 @@
 #include "cc/output/output_surface.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ -66,7 +66,7 @@ bool IOSurfaceLayerImpl::WillDraw(DrawMode draw_mode,
 
 void IOSurfaceLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
@@ -78,9 +78,7 @@ void IOSurfaceLayerImpl::AppendQuads(
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
   gfx::Rect visible_quad_rect =
-      occlusion_tracker.GetCurrentOcclusionForLayer(
-                            draw_properties().target_space_transform)
-          .GetUnoccludedContentRect(quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(quad_rect);
   if (visible_quad_rect.IsEmpty())
     return;
 
diff --git a/cc/layers/io_surface_layer_impl.h b/cc/layers/io_surface_layer_impl.h
index 15fa5bd..d6b6625 100644
--- a/cc/layers/io_surface_layer_impl.h
+++ b/cc/layers/io_surface_layer_impl.h
@@ -28,7 +28,7 @@ class CC_EXPORT IOSurfaceLayerImpl : public LayerImpl {
   virtual void PushPropertiesTo(LayerImpl* layer_tree_impl) override;
 
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
   virtual bool WillDraw(DrawMode draw_mode,
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 9bfc2e1..54dda06 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -195,7 +195,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider);
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) {}
   virtual void DidDraw(ResourceProvider* resource_provider);
 
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index ba3f30c..b350ba9 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -9,7 +9,7 @@
 #include "cc/base/math_util.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "ui/gfx/rect_f.h"
 
 namespace cc {
@@ -82,7 +82,7 @@ void NinePatchLayerImpl::CheckGeometryLimitations() {
 
 void NinePatchLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   CheckGeometryLimitations();
   SharedQuadState* shared_quad_state =
@@ -213,10 +213,8 @@ void NinePatchLayerImpl::AppendQuads(
   gfx::Rect visible_rect;
   const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-  Occlusion occlusion =
-      occlusion_tracker.GetCurrentOcclusionForLayer(draw_transform());
-
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_top_left);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_top_left);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -233,7 +231,8 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_top_right);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_top_right);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -250,7 +249,8 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_bottom_left);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_bottom_left);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -267,7 +267,8 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_bottom_right);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_bottom_right);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -284,7 +285,7 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_top);
+  visible_rect = occlusion_in_content_space.GetUnoccludedContentRect(layer_top);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -301,7 +302,8 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_left);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_left);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -318,7 +320,8 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_right);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_right);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -335,7 +338,8 @@ void NinePatchLayerImpl::AppendQuads(
                  flipped);
   }
 
-  visible_rect = occlusion.GetUnoccludedContentRect(layer_bottom);
+  visible_rect =
+      occlusion_in_content_space.GetUnoccludedContentRect(layer_bottom);
   if (!visible_rect.IsEmpty()) {
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -353,7 +357,8 @@ void NinePatchLayerImpl::AppendQuads(
   }
 
   if (fill_center_) {
-    visible_rect = occlusion.GetUnoccludedContentRect(layer_center);
+    visible_rect =
+        occlusion_in_content_space.GetUnoccludedContentRect(layer_center);
     if (!visible_rect.IsEmpty()) {
       TextureDrawQuad* quad =
           render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
diff --git a/cc/layers/nine_patch_layer_impl.h b/cc/layers/nine_patch_layer_impl.h
index 15a9e54..0674ecb 100644
--- a/cc/layers/nine_patch_layer_impl.h
+++ b/cc/layers/nine_patch_layer_impl.h
@@ -62,7 +62,7 @@ class CC_EXPORT NinePatchLayerImpl : public UIResourceLayerImpl {
   virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
   virtual base::DictionaryValue* LayerTreeAsJson() const override;
diff --git a/cc/layers/nine_patch_layer_impl_unittest.cc b/cc/layers/nine_patch_layer_impl_unittest.cc
index 98d28fc..2b82d48 100644
--- a/cc/layers/nine_patch_layer_impl_unittest.cc
+++ b/cc/layers/nine_patch_layer_impl_unittest.cc
@@ -35,7 +35,6 @@ void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
                               const gfx::Rect& border,
                               bool fill_center,
                               size_t expected_quad_size) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   gfx::Rect visible_content_rect(layer_size);
   gfx::Rect expected_remaining(border.x(),
@@ -63,7 +62,7 @@ void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
   layer->SetImageBounds(bitmap_size);
   layer->SetLayout(aperture_rect, border, fill_center);
   AppendQuadsData data;
-  layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  layer->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   // Verify quad rects
   const QuadList& quads = render_pass->quad_list;
diff --git a/cc/layers/painted_scrollbar_layer_impl.cc b/cc/layers/painted_scrollbar_layer_impl.cc
index 180c26d..b5de1e1 100644
--- a/cc/layers/painted_scrollbar_layer_impl.cc
+++ b/cc/layers/painted_scrollbar_layer_impl.cc
@@ -12,7 +12,7 @@
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/layer_tree_settings.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
@@ -69,7 +69,7 @@ bool PaintedScrollbarLayerImpl::WillDraw(DrawMode draw_mode,
 
 void PaintedScrollbarLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   bool premultipled_alpha = true;
   bool flipped = false;
@@ -85,10 +85,8 @@ void PaintedScrollbarLayerImpl::AppendQuads(
       render_pass, content_bounds(), shared_quad_state, append_quads_data);
 
   gfx::Rect thumb_quad_rect = ComputeThumbQuadRect();
-  Occlusion occlusion =
-      occlusion_tracker.GetCurrentOcclusionForLayer(draw_transform());
   gfx::Rect visible_thumb_quad_rect =
-      occlusion.GetUnoccludedContentRect(thumb_quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(thumb_quad_rect);
 
   ResourceProvider::ResourceId thumb_resource_id =
       layer_tree_impl()->ResourceIdForUIResource(thumb_ui_resource_id_);
@@ -115,7 +113,7 @@ void PaintedScrollbarLayerImpl::AppendQuads(
 
   gfx::Rect track_quad_rect = content_bounds_rect;
   gfx::Rect visible_track_quad_rect =
-      occlusion.GetUnoccludedContentRect(track_quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(track_quad_rect);
   if (track_resource_id && !visible_track_quad_rect.IsEmpty()) {
     gfx::Rect opaque_rect(contents_opaque() ? track_quad_rect : gfx::Rect());
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
diff --git a/cc/layers/painted_scrollbar_layer_impl.h b/cc/layers/painted_scrollbar_layer_impl.h
index d835223..1c67e73 100644
--- a/cc/layers/painted_scrollbar_layer_impl.h
+++ b/cc/layers/painted_scrollbar_layer_impl.h
@@ -31,7 +31,7 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
   void SetThumbThickness(int thumb_thickness);
diff --git a/cc/layers/picture_image_layer_impl_unittest.cc b/cc/layers/picture_image_layer_impl_unittest.cc
index 08f7c9c..7e92c0c 100644
--- a/cc/layers/picture_image_layer_impl_unittest.cc
+++ b/cc/layers/picture_image_layer_impl_unittest.cc
@@ -12,7 +12,6 @@
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "cc/test/impl_side_painting_settings.h"
-#include "cc/test/mock_occlusion_tracker.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -149,11 +148,10 @@ TEST_F(PictureImageLayerImplTest, IgnoreIdealContentScale) {
   // Draw.
   active_layer->draw_properties().visible_content_rect =
       gfx::Rect(gfx::ToCeiledSize(active_layer->bounds()));
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer->WillDraw(DRAW_MODE_SOFTWARE, NULL);
-  active_layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer->DidDraw(NULL);
 
   EXPECT_EQ(DrawQuad::TILED_CONTENT, render_pass->quad_list.front()->material);
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 76f90f2..8eb8f88 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -25,7 +25,7 @@
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/tile_manager.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
@@ -150,10 +150,9 @@ void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
   needs_push_properties_ = true;
 }
 
-void PictureLayerImpl::AppendQuads(
-    RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    AppendQuadsData* append_quads_data) {
+void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
+                                   const Occlusion& occlusion_in_content_space,
+                                   AppendQuadsData* append_quads_data) {
   DCHECK(!needs_post_commit_initialization_);
 
   SharedQuadState* shared_quad_state =
@@ -166,18 +165,14 @@ void PictureLayerImpl::AppendQuads(
         render_pass, content_bounds(), shared_quad_state, append_quads_data);
 
     SolidColorLayerImpl::AppendSolidQuads(render_pass,
-                                          occlusion_tracker,
+                                          occlusion_in_content_space,
                                           shared_quad_state,
                                           content_bounds(),
-                                          draw_transform(),
                                           pile_->solid_color(),
                                           append_quads_data);
     return;
   }
 
-  Occlusion occlusion =
-      occlusion_tracker.GetCurrentOcclusionForLayer(draw_transform());
-
   float max_contents_scale = MaximumTilingContentsScale();
   gfx::Transform scaled_draw_transform = draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
@@ -188,7 +183,8 @@ void PictureLayerImpl::AppendQuads(
       gfx::ScaleToEnclosingRect(visible_content_rect(), max_contents_scale);
   scaled_visible_content_rect.Intersect(gfx::Rect(scaled_content_bounds));
   Occlusion scaled_occlusion =
-      occlusion.GetOcclusionWithGivenDrawTransform(scaled_draw_transform);
+      occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
+          scaled_draw_transform);
 
   shared_quad_state->SetAll(scaled_draw_transform,
                             scaled_content_bounds,
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 035df7d..98b0a6e 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -107,7 +107,7 @@ class CC_EXPORT PictureLayerImpl
       override;
   virtual void PushPropertiesTo(LayerImpl* layer) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
   virtual void UpdateTiles(const Occlusion& occlusion_in_content_space,
                            bool resourceless_software_draw) override;
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index b409b1b..72794b3 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -1361,7 +1361,6 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
 }
 
 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(400, 400);
@@ -1383,7 +1382,7 @@ TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   ASSERT_EQ(1U, render_pass->quad_list.size());
@@ -1564,11 +1563,10 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
   host_impl_.active_tree()->UpdateDrawProperties();
   active_layer_->draw_properties().visible_content_rect = visible_content_rect;
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   // All tiles in activation rect is ready to draw.
@@ -1599,11 +1597,10 @@ TEST_F(PictureLayerImplTest, HighResTileIsComplete) {
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   // All high res tiles drew, nothing was incomplete.
@@ -1641,11 +1638,10 @@ TEST_F(PictureLayerImplTest, LowResTileIsIncomplete) {
       active_layer_->tilings()->tiling_at(1)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(low_tiles);
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   // The missing high res tile was replaced by a low res tile.
@@ -1703,11 +1699,10 @@ TEST_F(PictureLayerImplTest,
       active_layer_->HighResTiling()->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(high_tiles);
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   // All high res tiles drew, and the one ideal res tile drew.
@@ -3444,7 +3439,6 @@ TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
 }
 
 TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(400, 400);
@@ -3470,7 +3464,7 @@ TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
                               SK_MScalar1 / max_contents_scale);
 
   AppendQuadsData data;
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   // SharedQuadState should have be of size 1, as we are doing AppenQuad once.
   EXPECT_EQ(1u, render_pass->shared_quad_state_list.size());
@@ -3579,11 +3573,10 @@ TEST_F(PictureLayerImplTestWithDelegatingRenderer,
   host_impl_.SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   host_impl_.ManageTiles();
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_HARDWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   // Even when OOM, quads should be produced, and should be different material
@@ -4290,11 +4283,10 @@ void PictureLayerImplTest::TestQuadsForSolidColor(bool test_for_solid) {
     host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
   }
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, NULL);
-  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
   active_layer_->DidDraw(NULL);
 
   DrawQuad::Material expected = test_for_solid
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 7f4b40e..9db5d3b 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -345,11 +345,9 @@ TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
 
   // Thickness should be overridden to 3.
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
     AppendQuadsData data;
-    scrollbar_layer_impl->AppendQuads(
-        render_pass.get(), occlusion_tracker, &data);
+    scrollbar_layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     const QuadList& quads = render_pass->quad_list;
     ASSERT_EQ(1u, quads.size());
@@ -361,11 +359,9 @@ TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
   scrollbar_layer_impl->draw_properties().contents_scale_x = 2.f;
   scrollbar_layer_impl->draw_properties().contents_scale_y = 2.f;
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
     AppendQuadsData data;
-    scrollbar_layer_impl->AppendQuads(
-        render_pass.get(), occlusion_tracker, &data);
+    scrollbar_layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     const QuadList& quads = render_pass->quad_list;
     ASSERT_EQ(1u, quads.size());
@@ -379,11 +375,9 @@ TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
   // current viewport state.
   scrollbar_layer_impl->SetVisibleToTotalLengthRatio(0.2f);
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
     AppendQuadsData data;
-    scrollbar_layer_impl->AppendQuads(
-        render_pass.get(), occlusion_tracker, &data);
+    scrollbar_layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     const QuadList& quads = render_pass->quad_list;
     ASSERT_EQ(1u, quads.size());
@@ -395,11 +389,9 @@ TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
   scrollbar_layer_impl->SetCurrentPos(0.f);
   scrollbar_layer_impl->SetMaximum(0);
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
     AppendQuadsData data;
-    scrollbar_layer_impl->AppendQuads(
-        render_pass.get(), occlusion_tracker, &data);
+    scrollbar_layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     const QuadList& quads = render_pass->quad_list;
     ASSERT_EQ(1u, quads.size());
@@ -455,12 +447,10 @@ TEST(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
   scrollbar_layer_impl->SetMaximum(8);
 
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
-    scrollbar_layer_impl->AppendQuads(
-        render_pass.get(), occlusion_tracker, &data);
+    scrollbar_layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     const QuadList& quads = render_pass->quad_list;
     ASSERT_EQ(1u, quads.size());
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index 618ea53..c8ddc7d 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -8,7 +8,7 @@
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/solid_color_draw_quad.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 
 namespace cc {
 
@@ -29,15 +29,11 @@ scoped_ptr<LayerImpl> SolidColorLayerImpl::CreateLayerImpl(
 
 void SolidColorLayerImpl::AppendSolidQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     SharedQuadState* shared_quad_state,
     const gfx::Size& content_bounds,
-    const gfx::Transform& target_space_transform,
     SkColor color,
     AppendQuadsData* append_quads_data) {
-  Occlusion occlusion =
-      occlusion_tracker.GetCurrentOcclusionForLayer(target_space_transform);
-
   // We create a series of smaller quads instead of just one large one so that
   // the culler can reduce the total pixels drawn.
   int width = content_bounds.width();
@@ -49,7 +45,7 @@ void SolidColorLayerImpl::AppendSolidQuads(
                           std::min(width - x, kSolidQuadTileSize),
                           std::min(height - y, kSolidQuadTileSize));
       gfx::Rect visible_quad_rect =
-          occlusion.GetUnoccludedContentRect(quad_rect);
+          occlusion_in_content_space.GetUnoccludedContentRect(quad_rect);
       if (visible_quad_rect.IsEmpty())
         continue;
 
@@ -66,7 +62,7 @@ void SolidColorLayerImpl::AppendSolidQuads(
 
 void SolidColorLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
@@ -76,10 +72,9 @@ void SolidColorLayerImpl::AppendQuads(
       render_pass, content_bounds(), shared_quad_state, append_quads_data);
 
   AppendSolidQuads(render_pass,
-                   occlusion_tracker,
+                   occlusion_in_content_space,
                    shared_quad_state,
                    content_bounds(),
-                   draw_properties().target_space_transform,
                    background_color(),
                    append_quads_data);
 }
diff --git a/cc/layers/solid_color_layer_impl.h b/cc/layers/solid_color_layer_impl.h
index b9ab1cf..0116479 100644
--- a/cc/layers/solid_color_layer_impl.h
+++ b/cc/layers/solid_color_layer_impl.h
@@ -18,14 +18,12 @@ class CC_EXPORT SolidColorLayerImpl : public LayerImpl {
     return make_scoped_ptr(new SolidColorLayerImpl(tree_impl, id));
   }
 
-  static void AppendSolidQuads(
-      RenderPass* render_pass,
-      const OcclusionTracker<LayerImpl>& occlusion_tracker,
-      SharedQuadState* shared_quad_state,
-      const gfx::Size& content_bounds,
-      const gfx::Transform& target_space_transform,
-      SkColor color,
-      AppendQuadsData* append_quads_data);
+  static void AppendSolidQuads(RenderPass* render_pass,
+                               const Occlusion& occlusion_in_content_space,
+                               SharedQuadState* shared_quad_state,
+                               const gfx::Size& content_bounds,
+                               SkColor color,
+                               AppendQuadsData* append_quads_data);
 
   virtual ~SolidColorLayerImpl();
 
@@ -33,7 +31,7 @@ class CC_EXPORT SolidColorLayerImpl : public LayerImpl {
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
       override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
  protected:
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index 3e5f453..768fae4 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -21,7 +21,6 @@ namespace cc {
 namespace {
 
 TEST(SolidColorLayerImplTest, VerifyTilingCompleteAndNoOverlap) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_size = gfx::Size(800, 600);
@@ -39,7 +38,7 @@ TEST(SolidColorLayerImplTest, VerifyTilingCompleteAndNoOverlap) {
   layer->draw_properties().render_target = layer.get();
 
   AppendQuadsData data;
-  layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  layer->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
                                                visible_content_rect);
@@ -48,7 +47,6 @@ TEST(SolidColorLayerImplTest, VerifyTilingCompleteAndNoOverlap) {
 TEST(SolidColorLayerImplTest, VerifyCorrectBackgroundColorInQuad) {
   SkColor test_color = 0xFFA55AFF;
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_size = gfx::Size(100, 100);
@@ -67,7 +65,7 @@ TEST(SolidColorLayerImplTest, VerifyCorrectBackgroundColorInQuad) {
   layer->draw_properties().render_target = layer.get();
 
   AppendQuadsData data;
-  layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  layer->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   ASSERT_EQ(render_pass->quad_list.size(), 1U);
   EXPECT_EQ(
@@ -78,7 +76,6 @@ TEST(SolidColorLayerImplTest, VerifyCorrectBackgroundColorInQuad) {
 TEST(SolidColorLayerImplTest, VerifyCorrectOpacityInQuad) {
   const float opacity = 0.5f;
 
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_size = gfx::Size(100, 100);
@@ -97,7 +94,7 @@ TEST(SolidColorLayerImplTest, VerifyCorrectOpacityInQuad) {
   layer->draw_properties().render_target = layer.get();
 
   AppendQuadsData data;
-  layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  layer->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   ASSERT_EQ(render_pass->quad_list.size(), 1U);
   EXPECT_EQ(opacity,
@@ -141,11 +138,10 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
     // should be the full tile.
     layer_impl->draw_properties().opacity = 1;
 
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
-    layer_impl->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     ASSERT_EQ(render_pass->quad_list.size(), 1U);
     EXPECT_EQ(visible_content_rect.ToString(),
@@ -168,11 +164,10 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
     // should be empty.
     layer_impl->draw_properties().opacity = 1;
 
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
-    layer_impl->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer_impl->AppendQuads(render_pass.get(), Occlusion(), &data);
 
     ASSERT_EQ(render_pass->quad_list.size(), 1U);
     EXPECT_EQ(gfx::Rect().ToString(),
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.cc b/cc/layers/solid_color_scrollbar_layer_impl.cc
index a0c9609..db6a502 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl.cc
@@ -6,7 +6,7 @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/layer_tree_settings.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 
 namespace cc {
 
@@ -95,7 +95,7 @@ bool SolidColorScrollbarLayerImpl::IsThumbResizable() const {
 
 void SolidColorScrollbarLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
@@ -106,9 +106,7 @@ void SolidColorScrollbarLayerImpl::AppendQuads(
 
   gfx::Rect thumb_quad_rect(ComputeThumbQuadRect());
   gfx::Rect visible_quad_rect =
-      occlusion_tracker.GetCurrentOcclusionForLayer(
-                            draw_properties().target_space_transform)
-          .GetUnoccludedContentRect(thumb_quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(thumb_quad_rect);
   if (visible_quad_rect.IsEmpty())
     return;
 
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.h b/cc/layers/solid_color_scrollbar_layer_impl.h
index 93f1561..32695d0 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.h
+++ b/cc/layers/solid_color_scrollbar_layer_impl.h
@@ -28,7 +28,7 @@ class CC_EXPORT SolidColorScrollbarLayerImpl : public ScrollbarLayerImplBase {
   virtual void PushPropertiesTo(LayerImpl* layer) override;
 
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
  protected:
diff --git a/cc/layers/surface_layer_impl.cc b/cc/layers/surface_layer_impl.cc
index 352aca6..4fb9d95 100644
--- a/cc/layers/surface_layer_impl.cc
+++ b/cc/layers/surface_layer_impl.cc
@@ -7,7 +7,7 @@
 #include "base/debug/trace_event_argument.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/quads/surface_draw_quad.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 
 namespace cc {
 
@@ -37,10 +37,9 @@ void SurfaceLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer_impl->SetSurfaceId(surface_id_);
 }
 
-void SurfaceLayerImpl::AppendQuads(
-    RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    AppendQuadsData* append_quads_data) {
+void SurfaceLayerImpl::AppendQuads(RenderPass* render_pass,
+                                   const Occlusion& occlusion_in_content_space,
+                                   AppendQuadsData* append_quads_data) {
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);
@@ -53,9 +52,7 @@ void SurfaceLayerImpl::AppendQuads(
 
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect visible_quad_rect =
-      occlusion_tracker.GetCurrentOcclusionForLayer(
-                            draw_properties().target_space_transform)
-          .GetUnoccludedContentRect(quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(quad_rect);
   if (visible_quad_rect.IsEmpty())
     return;
   SurfaceDrawQuad* quad =
diff --git a/cc/layers/surface_layer_impl.h b/cc/layers/surface_layer_impl.h
index d791340..5353a21 100644
--- a/cc/layers/surface_layer_impl.h
+++ b/cc/layers/surface_layer_impl.h
@@ -26,7 +26,7 @@ class CC_EXPORT SurfaceLayerImpl : public LayerImpl {
       override;
   virtual void PushPropertiesTo(LayerImpl* layer) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
  protected:
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 206d8db..bcde7cd 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -13,7 +13,7 @@
 #include "cc/resources/scoped_resource.h"
 #include "cc/resources/single_release_callback_impl.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 
 namespace cc {
 
@@ -139,10 +139,9 @@ bool TextureLayerImpl::WillDraw(DrawMode draw_mode,
          LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
-void TextureLayerImpl::AppendQuads(
-    RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    AppendQuadsData* append_quads_data) {
+void TextureLayerImpl::AppendQuads(RenderPass* render_pass,
+                                   const Occlusion& occlusion_in_content_space,
+                                   AppendQuadsData* append_quads_data) {
   DCHECK(external_texture_resource_ || valid_texture_copy_);
 
   SharedQuadState* shared_quad_state =
@@ -159,9 +158,7 @@ void TextureLayerImpl::AppendQuads(
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect opaque_rect = opaque ? quad_rect : gfx::Rect();
   gfx::Rect visible_quad_rect =
-      occlusion_tracker.GetCurrentOcclusionForLayer(
-                            draw_properties().target_space_transform)
-          .GetUnoccludedContentRect(quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(quad_rect);
   if (visible_quad_rect.IsEmpty())
     return;
 
diff --git a/cc/layers/texture_layer_impl.h b/cc/layers/texture_layer_impl.h
index 8fe7f0c..bbf0817 100644
--- a/cc/layers/texture_layer_impl.h
+++ b/cc/layers/texture_layer_impl.h
@@ -29,7 +29,7 @@ class CC_EXPORT TextureLayerImpl : public LayerImpl {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
   virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
   virtual void ReleaseResources() override;
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index 18d9d1e..5a0e81d 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -16,7 +16,7 @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/quad_f.h"
@@ -155,10 +155,9 @@ bool TiledLayerImpl::WillDraw(DrawMode draw_mode,
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
-void TiledLayerImpl::AppendQuads(
-    RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    AppendQuadsData* append_quads_data) {
+void TiledLayerImpl::AppendQuads(RenderPass* render_pass,
+                                 const Occlusion& occlusion_in_content_space,
+                                 AppendQuadsData* append_quads_data) {
   DCHECK(tiler_);
   DCHECK(!tiler_->has_empty_bounds());
   DCHECK(!visible_content_rect().IsEmpty());
@@ -204,8 +203,6 @@ void TiledLayerImpl::AppendQuads(
   if (skips_draw_)
     return;
 
-  Occlusion occlusion =
-      occlusion_tracker.GetCurrentOcclusionForLayer(draw_transform());
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       DrawableTile* tile = TileAt(i, j);
@@ -218,7 +215,7 @@ void TiledLayerImpl::AppendQuads(
         continue;
 
       gfx::Rect visible_tile_rect =
-          occlusion.GetUnoccludedContentRect(tile_rect);
+          occlusion_in_content_space.GetUnoccludedContentRect(tile_rect);
       if (visible_tile_rect.IsEmpty())
         continue;
 
diff --git a/cc/layers/tiled_layer_impl.h b/cc/layers/tiled_layer_impl.h
index 0cd0741..0a65a96 100644
--- a/cc/layers/tiled_layer_impl.h
+++ b/cc/layers/tiled_layer_impl.h
@@ -29,7 +29,7 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
   virtual ResourceProvider::ResourceId ContentsResourceId() const override;
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index 50d7baa..ffc89c8 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -70,9 +70,8 @@ class TiledLayerImplTest : public testing::Test {
     layer->draw_properties().visible_content_rect = visible_content_rect;
     layer->SetBounds(layer_size);
 
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     AppendQuadsData data;
-    layer->AppendQuads(render_pass, occlusion_tracker, &data);
+    layer->AppendQuads(render_pass, Occlusion(), &data);
   }
 
  protected:
@@ -92,12 +91,11 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
   {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
     EXPECT_TRUE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
-    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer->AppendQuads(render_pass.get(), Occlusion(), &data);
     layer->DidDraw(NULL);
     unsigned num_tiles = num_tiles_x * num_tiles_y;
     EXPECT_EQ(render_pass->quad_list.size(), num_tiles);
@@ -109,7 +107,6 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
     layer->draw_properties().visible_content_rect = gfx::Rect();
 
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     EXPECT_FALSE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
@@ -123,12 +120,11 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
     gfx::Rect outside_bounds(-100, -100, 50, 50);
     layer->draw_properties().visible_content_rect = outside_bounds;
 
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
     EXPECT_TRUE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
-    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer->AppendQuads(render_pass.get(), Occlusion(), &data);
     layer->DidDraw(NULL);
     EXPECT_EQ(render_pass->quad_list.size(), 0u);
   }
@@ -139,11 +135,10 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
     layer->set_skips_draw(true);
 
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
-    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer->AppendQuads(render_pass.get(), Occlusion(), &data);
     EXPECT_EQ(render_pass->quad_list.size(), 0u);
   }
 }
@@ -160,11 +155,10 @@ TEST_F(TiledLayerImplTest, Checkerboarding) {
 
   // No checkerboarding
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
-    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer->AppendQuads(render_pass.get(), Occlusion(), &data);
     EXPECT_EQ(render_pass->quad_list.size(), 4u);
     EXPECT_EQ(0u, data.num_missing_tiles);
 
@@ -178,11 +172,10 @@ TEST_F(TiledLayerImplTest, Checkerboarding) {
 
   // All checkerboarding
   {
-    MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
-    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    layer->AppendQuads(render_pass.get(), Occlusion(), &data);
     EXPECT_LT(0u, data.num_missing_tiles);
     EXPECT_EQ(render_pass->quad_list.size(), 4u);
     for (const auto& quad : render_pass->quad_list)
diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index 4116377..e6c3def 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -9,7 +9,7 @@
 #include "cc/base/math_util.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/rect_f.h"
 
@@ -94,7 +94,7 @@ bool UIResourceLayerImpl::WillDraw(DrawMode draw_mode,
 
 void UIResourceLayerImpl::AppendQuads(
     RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
@@ -123,9 +123,7 @@ void UIResourceLayerImpl::AppendQuads(
   gfx::Rect quad_rect(gfx::ToCeiledSize(bounds()));
   gfx::Rect opaque_rect(opaque ? quad_rect : gfx::Rect());
   gfx::Rect visible_quad_rect =
-      occlusion_tracker.GetCurrentOcclusionForLayer(
-                            draw_properties().target_space_transform)
-          .GetUnoccludedContentRect(quad_rect);
+      occlusion_in_content_space.GetUnoccludedContentRect(quad_rect);
   if (visible_quad_rect.IsEmpty())
     return;
 
diff --git a/cc/layers/ui_resource_layer_impl.h b/cc/layers/ui_resource_layer_impl.h
index f214546..a0cb6ec 100644
--- a/cc/layers/ui_resource_layer_impl.h
+++ b/cc/layers/ui_resource_layer_impl.h
@@ -46,7 +46,7 @@ class CC_EXPORT UIResourceLayerImpl : public LayerImpl {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
   virtual base::DictionaryValue* LayerTreeAsJson() const override;
diff --git a/cc/layers/ui_resource_layer_impl_unittest.cc b/cc/layers/ui_resource_layer_impl_unittest.cc
index 5826394..01338f7 100644
--- a/cc/layers/ui_resource_layer_impl_unittest.cc
+++ b/cc/layers/ui_resource_layer_impl_unittest.cc
@@ -46,11 +46,10 @@ scoped_ptr<UIResourceLayerImpl> GenerateUIResourceLayer(
 
 void QuadSizeTest(scoped_ptr<UIResourceLayerImpl> layer,
                   size_t expected_quad_size) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   AppendQuadsData data;
-  layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  layer->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   // Verify quad rects
   const QuadList& quads = render_pass->quad_list;
@@ -87,11 +86,10 @@ TEST(UIResourceLayerImplTest, VerifyDrawQuads) {
 
 void OpaqueBoundsTest(scoped_ptr<UIResourceLayerImpl> layer,
                  const gfx::Rect& expected_opaque_bounds) {
-  MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   AppendQuadsData data;
-  layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+  layer->AppendQuads(render_pass.get(), Occlusion(), &data);
 
   // Verify quad rects
   const QuadList& quads = render_pass->quad_list;
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 2edea94..5e37397 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -14,7 +14,7 @@
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/single_release_callback_impl.h"
 #include "cc/trees/layer_tree_impl.h"
-#include "cc/trees/occlusion_tracker.h"
+#include "cc/trees/occlusion.h"
 #include "cc/trees/proxy.h"
 #include "media/base/video_frame.h"
 
@@ -129,10 +129,9 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
   return true;
 }
 
-void VideoLayerImpl::AppendQuads(
-    RenderPass* render_pass,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    AppendQuadsData* append_quads_data) {
+void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
+                                 const Occlusion& occlusion_in_content_space,
+                                 AppendQuadsData* append_quads_data) {
   DCHECK(frame_.get());
 
   gfx::Transform transform = draw_transform();
@@ -175,9 +174,10 @@ void VideoLayerImpl::AppendQuads(
   gfx::Rect visible_rect = frame_->visible_rect();
   gfx::Size coded_size = frame_->coded_size();
 
+  Occlusion occlusion_in_video_space =
+      occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(transform);
   gfx::Rect visible_quad_rect =
-      occlusion_tracker.GetCurrentOcclusionForLayer(transform)
-          .GetUnoccludedContentRect(quad_rect);
+      occlusion_in_video_space.GetUnoccludedContentRect(quad_rect);
   if (visible_quad_rect.IsEmpty())
     return;
 
diff --git a/cc/layers/video_layer_impl.h b/cc/layers/video_layer_impl.h
index 47d14e2..232a1c7 100644
--- a/cc/layers/video_layer_impl.h
+++ b/cc/layers/video_layer_impl.h
@@ -36,7 +36,7 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
   virtual bool WillDraw(DrawMode draw_mode,
                         ResourceProvider* resource_provider) override;
   virtual void AppendQuads(RenderPass* render_pass,
-                           const OcclusionTracker<LayerImpl>& occlusion_tracker,
+                           const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
   virtual void DidDraw(ResourceProvider* resource_provider) override;
   virtual void DidBecomeActive() override;