Home | History | Annotate | Download | only in layers 
      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 int RenderSurfaceImpl::OwningLayerId() const {
     57   return owning_layer_ ? owning_layer_->id() : 0;
     58 }
     59 
     60 
     61 void RenderSurfaceImpl::SetClipRect(const gfx::Rect& clip_rect) {
     62   if (clip_rect_ == clip_rect)
     63     return;
     64 
     65   surface_property_changed_ = true;
     66   clip_rect_ = clip_rect;
     67 }
     68 
     69 bool RenderSurfaceImpl::ContentsChanged() const {
     70   return !damage_tracker_->current_damage_rect().IsEmpty();
     71 }
     72 
     73 void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) {
     74   if (content_rect_ == content_rect)
     75     return;
     76 
     77   surface_property_changed_ = true;
     78   content_rect_ = content_rect;
     79 }
     80 
     81 bool RenderSurfaceImpl::SurfacePropertyChanged() const {
     82   // Surface property changes are tracked as follows:
     83   //
     84   // - surface_property_changed_ is flagged when the clip_rect or content_rect
     85   //   change. As of now, these are the only two properties that can be affected
     86   //   by descendant layers.
     87   //
     88   // - all other property changes come from the owning layer (or some ancestor
     89   //   layer that propagates its change to the owning layer).
     90   //
     91   DCHECK(owning_layer_);
     92   return surface_property_changed_ || owning_layer_->LayerPropertyChanged();
     93 }
     94 
     95 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
     96   return surface_property_changed_ && !owning_layer_->LayerPropertyChanged();
     97 }
     98 
     99 void RenderSurfaceImpl::AddContributingDelegatedRenderPassLayer(
    100     LayerImpl* layer) {
    101   DCHECK(std::find(layer_list_.begin(), layer_list_.end(), layer) !=
    102          layer_list_.end());
    103   DelegatedRendererLayerImpl* delegated_renderer_layer =
    104       static_cast<DelegatedRendererLayerImpl*>(layer);
    105   contributing_delegated_render_pass_layer_list_.push_back(
    106       delegated_renderer_layer);
    107 }
    108 
    109 void RenderSurfaceImpl::ClearLayerLists() {
    110   layer_list_.clear();
    111   contributing_delegated_render_pass_layer_list_.clear();
    112 }
    113 
    114 RenderPass::Id RenderSurfaceImpl::RenderPassId() {
    115   int layer_id = owning_layer_->id();
    116   int sub_id = 0;
    117   DCHECK_GT(layer_id, 0);
    118   return RenderPass::Id(layer_id, sub_id);
    119 }
    120 
    121 void RenderSurfaceImpl::AppendRenderPasses(RenderPassSink* pass_sink) {
    122   for (size_t i = 0;
    123        i < contributing_delegated_render_pass_layer_list_.size();
    124        ++i) {
    125     DelegatedRendererLayerImpl* delegated_renderer_layer =
    126         contributing_delegated_render_pass_layer_list_[i];
    127     delegated_renderer_layer->AppendContributingRenderPasses(pass_sink);
    128   }
    129 
    130   scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size());
    131   pass->SetNew(RenderPassId(),
    132                content_rect_,
    133                gfx::IntersectRects(content_rect_,
    134                                    damage_tracker_->current_damage_rect()),
    135                screen_space_transform_);
    136   pass_sink->AppendRenderPass(pass.Pass());
    137 }
    138 
    139 void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
    140                                     AppendQuadsData* append_quads_data,
    141                                     bool for_replica,
    142                                     RenderPass::Id render_pass_id) {
    143   DCHECK(!for_replica || owning_layer_->has_replica());
    144 
    145   const gfx::Transform& draw_transform =
    146       for_replica ? replica_draw_transform_ : draw_transform_;
    147   gfx::Rect visible_content_rect =
    148       quad_sink->UnoccludedContributingSurfaceContentRect(content_rect_,
    149                                                           draw_transform);
    150   if (visible_content_rect.IsEmpty())
    151     return;
    152 
    153   SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
    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                             owning_layer_->sorting_context_id());
    162 
    163   if (owning_layer_->ShowDebugBorders()) {
    164     SkColor color = for_replica ?
    165                     DebugColors::SurfaceReplicaBorderColor() :
    166                     DebugColors::SurfaceBorderColor();
    167     float width = for_replica ?
    168                   DebugColors::SurfaceReplicaBorderWidth(
    169                       owning_layer_->layer_tree_impl()) :
    170                   DebugColors::SurfaceBorderWidth(
    171                       owning_layer_->layer_tree_impl());
    172     scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
    173         DebugBorderDrawQuad::Create();
    174     debug_border_quad->SetNew(
    175         shared_quad_state, content_rect_, visible_content_rect, color, width);
    176     quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
    177   }
    178 
    179   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
    180   // and its reflection, it's currently not possible to apply a separate mask to
    181   // the reflection layer or correctly handle opacity in reflections (opacity
    182   // must be applied after drawing both the layer and its reflection). The
    183   // solution is to introduce yet another RenderSurfaceImpl to draw the layer
    184   // and its reflection in. For now we only apply a separate reflection mask if
    185   // the contents don't have a mask of their own.
    186   LayerImpl* mask_layer = owning_layer_->mask_layer();
    187   if (mask_layer &&
    188       (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
    189     mask_layer = NULL;
    190 
    191   if (!mask_layer && for_replica) {
    192     mask_layer = owning_layer_->replica_layer()->mask_layer();
    193     if (mask_layer &&
    194         (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
    195       mask_layer = NULL;
    196   }
    197 
    198   gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
    199   if (mask_layer) {
    200     gfx::Vector2dF owning_layer_draw_scale =
    201         MathUtil::ComputeTransform2dScaleComponents(
    202             owning_layer_->draw_transform(), 1.f);
    203     gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
    204         owning_layer_->content_bounds(),
    205         owning_layer_draw_scale.x(),
    206         owning_layer_draw_scale.y());
    207 
    208     float uv_scale_x =
    209         content_rect_.width() / unclipped_mask_target_size.width();
    210     float uv_scale_y =
    211         content_rect_.height() / unclipped_mask_target_size.height();
    212 
    213     mask_uv_rect = gfx::RectF(
    214         uv_scale_x * content_rect_.x() / content_rect_.width(),
    215         uv_scale_y * content_rect_.y() / content_rect_.height(),
    216         uv_scale_x,
    217         uv_scale_y);
    218   }
    219 
    220   ResourceProvider::ResourceId mask_resource_id =
    221       mask_layer ? mask_layer->ContentsResourceId() : 0;
    222   gfx::Rect contents_changed_since_last_frame =
    223       ContentsChanged() ? content_rect_ : gfx::Rect();
    224 
    225   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
    226   quad->SetNew(shared_quad_state,
    227                content_rect_,
    228                visible_content_rect,
    229                render_pass_id,
    230                for_replica,
    231                mask_resource_id,
    232                contents_changed_since_last_frame,
    233                mask_uv_rect,
    234                owning_layer_->filters(),
    235                owning_layer_->background_filters());
    236   quad_sink->Append(quad.PassAs<DrawQuad>());
    237 }
    238 
    239 }  // namespace cc
    240