cc/layers/render_surface_impl.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/layers/render_surface_impl.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "cc/base/math_util.h"
  12 #include "cc/debug/debug_colors.h"
  13 #include "cc/layers/delegated_renderer_layer_impl.h"
  14 #include "cc/layers/layer_impl.h"
  15 #include "cc/layers/quad_sink.h"
  16 #include "cc/layers/render_pass_sink.h"
  17 #include "cc/quads/debug_border_draw_quad.h"
  18 #include "cc/quads/render_pass.h"
  19 #include "cc/quads/render_pass_draw_quad.h"
  20 #include "cc/quads/shared_quad_state.h"
  21 #include "cc/trees/damage_tracker.h"
  22 #include "third_party/skia/include/core/SkImageFilter.h"
  23 #include "ui/gfx/rect_conversions.h"
  24 #include "ui/gfx/transform.h"
  25
  26 namespace cc {
  27
  28 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
  29     : owning_layer_(owning_layer),
  30       surface_property_changed_(false),
  31       draw_opacity_is_animating_(false),
  32       target_surface_transforms_are_animating_(false),
  33       screen_space_transforms_are_animating_(false),
  34       is_clipped_(false),
  35       contributes_to_drawn_surface_(false),
  36       draw_opacity_(1),
  37       nearest_occlusion_immune_ancestor_(NULL),
  38       target_render_surface_layer_index_history_(0),
  39       current_layer_index_history_(0) {
  40   damage_tracker_ = DamageTracker::Create();
  41 }
  42
  43 RenderSurfaceImpl::~RenderSurfaceImpl() {}
  44
  45 gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
  46   gfx::RectF drawable_content_rect =
  47       MathUtil::MapClippedRect(draw_transform_, content_rect_);
  48   if (owning_layer_->has_replica()) {
  49     drawable_content_rect.Union(
  50         MathUtil::MapClippedRect(replica_draw_transform_, content_rect_));
  51   }
  52
  53   return drawable_content_rect;
  54 }
  55
  56 std::string RenderSurfaceImpl::Name() const {
  57   return base::StringPrintf("RenderSurfaceImpl(id=%i,owner=%s)",
  58                             owning_layer_->id(),
  59                             owning_layer_->debug_name().data());
  60 }
  61
  62 int RenderSurfaceImpl::OwningLayerId() const {
  63   return owning_layer_ ? owning_layer_->id() : 0;
  64 }
  65
  66
  67 void RenderSurfaceImpl::SetClipRect(gfx::Rect clip_rect) {
  68   if (clip_rect_ == clip_rect)
  69     return;
  70
  71   surface_property_changed_ = true;
  72   clip_rect_ = clip_rect;
  73 }
  74
  75 bool RenderSurfaceImpl::ContentsChanged() const {
  76   return !damage_tracker_->current_damage_rect().IsEmpty();
  77 }
  78
  79 void RenderSurfaceImpl::SetContentRect(gfx::Rect content_rect) {
  80   if (content_rect_ == content_rect)
  81     return;
  82
  83   surface_property_changed_ = true;
  84   content_rect_ = content_rect;
  85 }
  86
  87 bool RenderSurfaceImpl::SurfacePropertyChanged() const {
  88   // Surface property changes are tracked as follows:
  89   //
  90   // - surface_property_changed_ is flagged when the clip_rect or content_rect
  91   //   change. As of now, these are the only two properties that can be affected
  92   //   by descendant layers.
  93   //
  94   // - all other property changes come from the owning layer (or some ancestor
  95   //   layer that propagates its change to the owning layer).
  96   //
  97   DCHECK(owning_layer_);
  98   return surface_property_changed_ || owning_layer_->LayerPropertyChanged();
  99 }
 100
 101 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
 102   return surface_property_changed_ && !owning_layer_->LayerPropertyChanged();
 103 }
 104
 105 void RenderSurfaceImpl::AddContributingDelegatedRenderPassLayer(
 106     LayerImpl* layer) {
 107   DCHECK(std::find(layer_list_.begin(), layer_list_.end(), layer) !=
 108          layer_list_.end());
 109   DelegatedRendererLayerImpl* delegated_renderer_layer =
 110       static_cast<DelegatedRendererLayerImpl*>(layer);
 111   contributing_delegated_render_pass_layer_list_.push_back(
 112       delegated_renderer_layer);
 113 }
 114
 115 void RenderSurfaceImpl::ClearLayerLists() {
 116   layer_list_.clear();
 117   contributing_delegated_render_pass_layer_list_.clear();
 118 }
 119
 120 RenderPass::Id RenderSurfaceImpl::RenderPassId() {
 121   int layer_id = owning_layer_->id();
 122   int sub_id = 0;
 123   DCHECK_GT(layer_id, 0);
 124   return RenderPass::Id(layer_id, sub_id);
 125 }
 126
 127 void RenderSurfaceImpl::AppendRenderPasses(RenderPassSink* pass_sink) {
 128   for (size_t i = 0;
 129        i < contributing_delegated_render_pass_layer_list_.size();
 130        ++i) {
 131     DelegatedRendererLayerImpl* delegated_renderer_layer =
 132         contributing_delegated_render_pass_layer_list_[i];
 133     delegated_renderer_layer->AppendContributingRenderPasses(pass_sink);
 134   }
 135
 136   scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size());
 137   pass->SetNew(RenderPassId(),
 138                content_rect_,
 139                damage_tracker_->current_damage_rect(),
 140                screen_space_transform_);
 141   pass_sink->AppendRenderPass(pass.Pass());
 142 }
 143
 144 void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
 145                                     AppendQuadsData* append_quads_data,
 146                                     bool for_replica,
 147                                     RenderPass::Id render_pass_id) {
 148   DCHECK(!for_replica || owning_layer_->has_replica());
 149
 150   const gfx::Transform& draw_transform =
 151       for_replica ? replica_draw_transform_ : draw_transform_;
 152   SharedQuadState* shared_quad_state =
 153       quad_sink->UseSharedQuadState(SharedQuadState::Create());
 154   shared_quad_state->SetAll(draw_transform,
 155                             content_rect_.size(),
 156                             content_rect_,
 157                             clip_rect_,
 158                             is_clipped_,
 159                             draw_opacity_,
 160                             owning_layer_->blend_mode());
 161
 162   if (owning_layer_->ShowDebugBorders()) {
 163     SkColor color = for_replica ?
 164                     DebugColors::SurfaceReplicaBorderColor() :
 165                     DebugColors::SurfaceBorderColor();
 166     float width = for_replica ?
 167                   DebugColors::SurfaceReplicaBorderWidth(
 168                       owning_layer_->layer_tree_impl()) :
 169                   DebugColors::SurfaceBorderWidth(
 170                       owning_layer_->layer_tree_impl());
 171     scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
 172         DebugBorderDrawQuad::Create();
 173     debug_border_quad->SetNew(shared_quad_state, content_rect_, color, width);
 174     quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(), append_quads_data);
 175   }
 176
 177   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
 178   // and its reflection, it's currently not possible to apply a separate mask to
 179   // the reflection layer or correctly handle opacity in reflections (opacity
 180   // must be applied after drawing both the layer and its reflection). The
 181   // solution is to introduce yet another RenderSurfaceImpl to draw the layer
 182   // and its reflection in. For now we only apply a separate reflection mask if
 183   // the contents don't have a mask of their own.
 184   LayerImpl* mask_layer = owning_layer_->mask_layer();
 185   if (mask_layer &&
 186       (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
 187     mask_layer = NULL;
 188
 189   if (!mask_layer && for_replica) {
 190     mask_layer = owning_layer_->replica_layer()->mask_layer();
 191     if (mask_layer &&
 192         (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
 193       mask_layer = NULL;
 194   }
 195
 196   gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
 197   if (mask_layer) {
 198     gfx::Vector2dF owning_layer_draw_scale =
 199         MathUtil::ComputeTransform2dScaleComponents(
 200             owning_layer_->draw_transform(), 1.f);
 201     gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
 202         owning_layer_->content_bounds(),
 203         owning_layer_draw_scale.x(),
 204         owning_layer_draw_scale.y());
 205
 206     float uv_scale_x =
 207         content_rect_.width() / unclipped_mask_target_size.width();
 208     float uv_scale_y =
 209         content_rect_.height() / unclipped_mask_target_size.height();
 210
 211     mask_uv_rect = gfx::RectF(
 212         uv_scale_x * content_rect_.x() / content_rect_.width(),
 213         uv_scale_y * content_rect_.y() / content_rect_.height(),
 214         uv_scale_x,
 215         uv_scale_y);
 216   }
 217
 218   ResourceProvider::ResourceId mask_resource_id =
 219       mask_layer ? mask_layer->ContentsResourceId() : 0;
 220   gfx::Rect contents_changed_since_last_frame =
 221       ContentsChanged() ? content_rect_ : gfx::Rect();
 222
 223   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
 224   quad->SetNew(shared_quad_state,
 225                content_rect_,
 226                render_pass_id,
 227                for_replica,
 228                mask_resource_id,
 229                contents_changed_since_last_frame,
 230                mask_uv_rect,
 231                owning_layer_->filters(),
 232                owning_layer_->background_filters());
 233   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 234 }
 235
 236 }  // namespace cc