cc: Pass Occlusion instead of OcclusionTracker to LayerImpls

cc/layers/video_layer_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/video_layer_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #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"
 
 #if defined(VIDEO_HOLE)
 #include "cc/quads/solid_color_draw_quad.h"
 #endif  // defined(VIDEO_HOLE)
 
 namespace cc {
 
 // static
@@ skipping 94 matching lines @@
     unsigned resource_id = resource_provider->CreateResourceFromTextureMailbox(
         external_resources.mailboxes[i],
         SingleReleaseCallbackImpl::Create(
             external_resources.release_callbacks[i]));
     frame_resources_.push_back(resource_id);
   }
 
   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();
   gfx::Size rotated_size = content_bounds();
 
   switch (video_rotation_) {
     case media::VIDEO_ROTATION_90:
       rotated_size = gfx::Size(rotated_size.height(), rotated_size.width());
       transform.Rotate(90.0);
       transform.Translate(0.0, -rotated_size.height());
@@ skipping 22 matching lines @@
                             sorting_context_id());
 
   AppendDebugBorderQuad(
       render_pass, rotated_size, shared_quad_state, append_quads_data);
 
   gfx::Rect quad_rect(rotated_size);
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
   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;
 
   // Pixels for macroblocked formats.
   const float tex_width_scale =
       static_cast<float>(visible_rect.width()) / coded_size.width();
   const float tex_height_scale =
       static_cast<float>(visible_rect.height()) / coded_size.height();
   const float tex_x_offset =
       static_cast<float>(visible_rect.x()) / coded_size.width();
@@ skipping 177 matching lines @@
 void VideoLayerImpl::SetProviderClientImpl(
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) {
   provider_client_impl_ = provider_client_impl;
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "cc::VideoLayerImpl";
 }
 
 }  // namespace cc