Home | History | Annotate | Download | only in layers 
      1 // Copyright 2012 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/delegated_renderer_layer_impl.h"
      6 
      7 #include <algorithm>
      8 #include <utility>
      9 
     10 #include "base/bind.h"
     11 #include "base/containers/hash_tables.h"
     12 #include "cc/base/math_util.h"
     13 #include "cc/layers/append_quads_data.h"
     14 #include "cc/layers/quad_sink.h"
     15 #include "cc/layers/render_pass_sink.h"
     16 #include "cc/output/delegated_frame_data.h"
     17 #include "cc/quads/render_pass_draw_quad.h"
     18 #include "cc/quads/solid_color_draw_quad.h"
     19 #include "cc/trees/layer_tree_impl.h"
     20 
     21 namespace cc {
     22 
     23 DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(LayerTreeImpl* tree_impl,
     24                                                        int id)
     25     : LayerImpl(tree_impl, id),
     26       have_render_passes_to_push_(false),
     27       inverse_device_scale_factor_(1.0f),
     28       child_id_(0),
     29       own_child_id_(false) {
     30 }
     31 
     32 DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl() {
     33   ClearRenderPasses();
     34   ClearChildId();
     35 }
     36 
     37 bool DelegatedRendererLayerImpl::HasDelegatedContent() const { return true; }
     38 
     39 bool DelegatedRendererLayerImpl::HasContributingDelegatedRenderPasses() const {
     40   // The root RenderPass for the layer is merged with its target
     41   // RenderPass in each frame. So we only have extra RenderPasses
     42   // to merge when we have a non-root RenderPass present.
     43   return render_passes_in_draw_order_.size() > 1;
     44 }
     45 
     46 static ResourceProvider::ResourceId ResourceRemapHelper(
     47     bool* invalid_frame,
     48     const ResourceProvider::ResourceIdMap& child_to_parent_map,
     49     ResourceProvider::ResourceIdArray* resources_in_frame,
     50     ResourceProvider::ResourceId id) {
     51 
     52   ResourceProvider::ResourceIdMap::const_iterator it =
     53       child_to_parent_map.find(id);
     54   if (it == child_to_parent_map.end()) {
     55     *invalid_frame = true;
     56     return 0;
     57   }
     58 
     59   DCHECK_EQ(it->first, id);
     60   ResourceProvider::ResourceId remapped_id = it->second;
     61   resources_in_frame->push_back(id);
     62   return remapped_id;
     63 }
     64 
     65 void DelegatedRendererLayerImpl::PushPropertiesTo(LayerImpl* layer) {
     66   LayerImpl::PushPropertiesTo(layer);
     67 
     68   DelegatedRendererLayerImpl* delegated_layer =
     69       static_cast<DelegatedRendererLayerImpl*>(layer);
     70 
     71   // If we have a new child_id to give to the active layer, it should
     72   // have already deleted its old child_id.
     73   DCHECK(delegated_layer->child_id_ == 0 ||
     74          delegated_layer->child_id_ == child_id_);
     75   delegated_layer->inverse_device_scale_factor_ = inverse_device_scale_factor_;
     76   delegated_layer->child_id_ = child_id_;
     77   delegated_layer->own_child_id_ = true;
     78   own_child_id_ = false;
     79 
     80   if (have_render_passes_to_push_) {
     81     // This passes ownership of the render passes to the active tree.
     82     delegated_layer->SetRenderPasses(&render_passes_in_draw_order_);
     83     DCHECK(render_passes_in_draw_order_.empty());
     84     have_render_passes_to_push_ = false;
     85   }
     86 
     87   // This is just a copy for testing, since resources are added to the
     88   // ResourceProvider in the pending tree.
     89   delegated_layer->resources_ = resources_;
     90 }
     91 
     92 void DelegatedRendererLayerImpl::CreateChildIdIfNeeded(
     93     const ReturnCallback& return_callback) {
     94   if (child_id_)
     95     return;
     96 
     97   ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
     98   child_id_ = resource_provider->CreateChild(return_callback);
     99   own_child_id_ = true;
    100 }
    101 
    102 void DelegatedRendererLayerImpl::SetFrameData(
    103     const DelegatedFrameData* frame_data,
    104     const gfx::RectF& damage_in_frame) {
    105   DCHECK(child_id_) << "CreateChildIdIfNeeded must be called first.";
    106   DCHECK(frame_data);
    107   DCHECK(!frame_data->render_pass_list.empty());
    108   // A frame with an empty root render pass is invalid.
    109   DCHECK(!frame_data->render_pass_list.back()->output_rect.IsEmpty());
    110 
    111   ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
    112     const ResourceProvider::ResourceIdMap& resource_map =
    113         resource_provider->GetChildToParentMap(child_id_);
    114 
    115   resource_provider->ReceiveFromChild(child_id_, frame_data->resource_list);
    116 
    117   ScopedPtrVector<RenderPass> render_pass_list;
    118   RenderPass::CopyAll(frame_data->render_pass_list, &render_pass_list);
    119 
    120   bool invalid_frame = false;
    121   ResourceProvider::ResourceIdArray resources_in_frame;
    122   DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
    123       base::Bind(&ResourceRemapHelper,
    124                  &invalid_frame,
    125                  resource_map,
    126                  &resources_in_frame);
    127   for (size_t i = 0; i < render_pass_list.size(); ++i) {
    128     RenderPass* pass = render_pass_list[i];
    129     for (size_t j = 0; j < pass->quad_list.size(); ++j) {
    130       DrawQuad* quad = pass->quad_list[j];
    131       quad->IterateResources(remap_resources_to_parent_callback);
    132     }
    133   }
    134 
    135   if (invalid_frame) {
    136     // Declare we are still using the last frame's resources.
    137     resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
    138     return;
    139   }
    140 
    141   // Declare we are using the new frame's resources.
    142   resources_.swap(resources_in_frame);
    143   resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
    144 
    145   inverse_device_scale_factor_ = 1.0f / frame_data->device_scale_factor;
    146   // Display size is already set so we can compute what the damage rect
    147   // will be in layer space. The damage may exceed the visible portion of
    148   // the frame, so intersect the damage to the layer's bounds.
    149   RenderPass* new_root_pass = render_pass_list.back();
    150   gfx::Size frame_size = new_root_pass->output_rect.size();
    151   gfx::RectF damage_in_layer = damage_in_frame;
    152   damage_in_layer.Scale(inverse_device_scale_factor_);
    153   SetUpdateRect(gfx::IntersectRects(
    154       gfx::UnionRects(update_rect(), damage_in_layer), gfx::Rect(bounds())));
    155 
    156   SetRenderPasses(&render_pass_list);
    157   have_render_passes_to_push_ = true;
    158 }
    159 
    160 void DelegatedRendererLayerImpl::SetRenderPasses(
    161     ScopedPtrVector<RenderPass>* render_passes_in_draw_order) {
    162   ClearRenderPasses();
    163 
    164   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
    165     ScopedPtrVector<RenderPass>::iterator to_take =
    166         render_passes_in_draw_order->begin() + i;
    167     render_passes_index_by_id_.insert(
    168         std::pair<RenderPass::Id, int>((*to_take)->id, i));
    169     scoped_ptr<RenderPass> taken_render_pass =
    170         render_passes_in_draw_order->take(to_take);
    171     render_passes_in_draw_order_.push_back(taken_render_pass.Pass());
    172   }
    173 
    174   // Give back an empty array instead of nulls.
    175   render_passes_in_draw_order->clear();
    176 }
    177 
    178 void DelegatedRendererLayerImpl::ClearRenderPasses() {
    179   render_passes_index_by_id_.clear();
    180   render_passes_in_draw_order_.clear();
    181 }
    182 
    183 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
    184     LayerTreeImpl* tree_impl) {
    185   return DelegatedRendererLayerImpl::Create(
    186       tree_impl, id()).PassAs<LayerImpl>();
    187 }
    188 
    189 void DelegatedRendererLayerImpl::ReleaseResources() {
    190   ClearRenderPasses();
    191   ClearChildId();
    192 }
    193 
    194 static inline int IndexToId(int index) { return index + 1; }
    195 static inline int IdToIndex(int id) { return id - 1; }
    196 
    197 RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId()
    198     const {
    199   return RenderPass::Id(id(), IndexToId(0));
    200 }
    201 
    202 RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
    203     RenderPass::Id previous) const {
    204   return RenderPass::Id(previous.layer_id, previous.index + 1);
    205 }
    206 
    207 bool DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId(
    208     RenderPass::Id delegated_render_pass_id,
    209     RenderPass::Id* output_render_pass_id) const {
    210   base::hash_map<RenderPass::Id, int>::const_iterator found =
    211       render_passes_index_by_id_.find(delegated_render_pass_id);
    212   if (found == render_passes_index_by_id_.end()) {
    213     // Be robust against a RenderPass id that isn't part of the frame.
    214     return false;
    215   }
    216   unsigned delegated_render_pass_index = found->second;
    217   *output_render_pass_id =
    218       RenderPass::Id(id(), IndexToId(delegated_render_pass_index));
    219   return true;
    220 }
    221 
    222 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
    223     RenderPassSink* render_pass_sink) {
    224   DCHECK(HasContributingDelegatedRenderPasses());
    225 
    226   const RenderPass* root_delegated_render_pass =
    227       render_passes_in_draw_order_.back();
    228   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
    229   gfx::Transform delegated_frame_to_root_transform = screen_space_transform();
    230   delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_,
    231                                           inverse_device_scale_factor_);
    232 
    233   for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
    234     RenderPass::Id output_render_pass_id(-1, -1);
    235     bool present =
    236         ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id,
    237                                      &output_render_pass_id);
    238 
    239     // Don't clash with the RenderPass we generate if we own a RenderSurface.
    240     DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", "
    241                     << render_passes_in_draw_order_[i]->id.index;
    242     DCHECK_GT(output_render_pass_id.index, 0);
    243 
    244     scoped_ptr<RenderPass> copy_pass =
    245         render_passes_in_draw_order_[i]->Copy(output_render_pass_id);
    246     copy_pass->transform_to_root_target.ConcatTransform(
    247         delegated_frame_to_root_transform);
    248     render_pass_sink->AppendRenderPass(copy_pass.Pass());
    249   }
    250 }
    251 
    252 bool DelegatedRendererLayerImpl::WillDraw(DrawMode draw_mode,
    253                                           ResourceProvider* resource_provider) {
    254   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
    255     return false;
    256   return LayerImpl::WillDraw(draw_mode, resource_provider);
    257 }
    258 
    259 void DelegatedRendererLayerImpl::AppendQuads(
    260     QuadSink* quad_sink,
    261     AppendQuadsData* append_quads_data) {
    262   AppendRainbowDebugBorder(quad_sink, append_quads_data);
    263 
    264   // This list will be empty after a lost context until a new frame arrives.
    265   if (render_passes_in_draw_order_.empty())
    266     return;
    267 
    268   RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
    269 
    270   const RenderPass* root_delegated_render_pass =
    271       render_passes_in_draw_order_.back();
    272 
    273   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
    274   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
    275 
    276   // If the index of the RenderPassId is 0, then it is a RenderPass generated
    277   // for a layer in this compositor, not the delegating renderer. Then we want
    278   // to merge our root RenderPass with the target RenderPass. Otherwise, it is
    279   // some RenderPass which we added from the delegating renderer.
    280   bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
    281   if (should_merge_root_render_pass_with_target) {
    282     // Verify that the RenderPass we are appending to is created by our
    283     // render_target.
    284     DCHECK(target_render_pass_id.layer_id == render_target()->id());
    285 
    286     AppendRenderPassQuads(
    287         quad_sink, append_quads_data, root_delegated_render_pass, frame_size);
    288   } else {
    289     // Verify that the RenderPass we are appending to was created by us.
    290     DCHECK(target_render_pass_id.layer_id == id());
    291 
    292     int render_pass_index = IdToIndex(target_render_pass_id.index);
    293     const RenderPass* delegated_render_pass =
    294         render_passes_in_draw_order_[render_pass_index];
    295     AppendRenderPassQuads(
    296         quad_sink, append_quads_data, delegated_render_pass, frame_size);
    297   }
    298 }
    299 
    300 void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
    301     QuadSink* quad_sink,
    302     AppendQuadsData* append_quads_data) {
    303   if (!ShowDebugBorders())
    304     return;
    305 
    306   SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
    307   PopulateSharedQuadState(shared_quad_state);
    308 
    309   SkColor color;
    310   float border_width;
    311   GetDebugBorderProperties(&color, &border_width);
    312 
    313   SkColor colors[] = {
    314     0x80ff0000,  // Red.
    315     0x80ffa500,  // Orange.
    316     0x80ffff00,  // Yellow.
    317     0x80008000,  // Green.
    318     0x800000ff,  // Blue.
    319     0x80ee82ee,  // Violet.
    320   };
    321   const int kNumColors = arraysize(colors);
    322 
    323   const int kStripeWidth = 300;
    324   const int kStripeHeight = 300;
    325 
    326   for (size_t i = 0; ; ++i) {
    327     // For horizontal lines.
    328     int x =  kStripeWidth * i;
    329     int width = std::min(kStripeWidth, content_bounds().width() - x - 1);
    330 
    331     // For vertical lines.
    332     int y = kStripeHeight * i;
    333     int height = std::min(kStripeHeight, content_bounds().height() - y - 1);
    334 
    335     gfx::Rect top(x, 0, width, border_width);
    336     gfx::Rect bottom(x,
    337                      content_bounds().height() - border_width,
    338                      width,
    339                      border_width);
    340     gfx::Rect left(0, y, border_width, height);
    341     gfx::Rect right(content_bounds().width() - border_width,
    342                     y,
    343                     border_width,
    344                     height);
    345 
    346     if (top.IsEmpty() && left.IsEmpty())
    347       break;
    348 
    349     if (!top.IsEmpty()) {
    350       scoped_ptr<SolidColorDrawQuad> top_quad = SolidColorDrawQuad::Create();
    351       top_quad->SetNew(
    352           shared_quad_state, top, top, colors[i % kNumColors], false);
    353       quad_sink->Append(top_quad.PassAs<DrawQuad>());
    354 
    355       scoped_ptr<SolidColorDrawQuad> bottom_quad = SolidColorDrawQuad::Create();
    356       bottom_quad->SetNew(shared_quad_state,
    357                           bottom,
    358                           bottom,
    359                           colors[kNumColors - 1 - (i % kNumColors)],
    360                           false);
    361       quad_sink->Append(bottom_quad.PassAs<DrawQuad>());
    362     }
    363     if (!left.IsEmpty()) {
    364       scoped_ptr<SolidColorDrawQuad> left_quad = SolidColorDrawQuad::Create();
    365       left_quad->SetNew(shared_quad_state,
    366                         left,
    367                         left,
    368                         colors[kNumColors - 1 - (i % kNumColors)],
    369                         false);
    370       quad_sink->Append(left_quad.PassAs<DrawQuad>());
    371 
    372       scoped_ptr<SolidColorDrawQuad> right_quad = SolidColorDrawQuad::Create();
    373       right_quad->SetNew(
    374           shared_quad_state, right, right, colors[i % kNumColors], false);
    375       quad_sink->Append(right_quad.PassAs<DrawQuad>());
    376     }
    377   }
    378 }
    379 
    380 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
    381     QuadSink* quad_sink,
    382     AppendQuadsData* append_quads_data,
    383     const RenderPass* delegated_render_pass,
    384     const gfx::Size& frame_size) const {
    385 
    386   const SharedQuadState* delegated_shared_quad_state = NULL;
    387   SharedQuadState* output_shared_quad_state = NULL;
    388 
    389   for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
    390     const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
    391 
    392     bool is_root_delegated_render_pass =
    393         delegated_render_pass == render_passes_in_draw_order_.back();
    394 
    395     if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
    396       delegated_shared_quad_state = delegated_quad->shared_quad_state;
    397       output_shared_quad_state = quad_sink->CreateSharedQuadState();
    398       output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
    399 
    400       if (is_root_delegated_render_pass) {
    401         gfx::Transform delegated_frame_to_target_transform = draw_transform();
    402         delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
    403                                                   inverse_device_scale_factor_);
    404 
    405         output_shared_quad_state->content_to_target_transform.ConcatTransform(
    406             delegated_frame_to_target_transform);
    407 
    408         if (render_target() == this) {
    409           DCHECK(!is_clipped());
    410           DCHECK(render_surface());
    411           DCHECK_EQ(0, num_unclipped_descendants());
    412           output_shared_quad_state->clip_rect =
    413               MathUtil::MapEnclosingClippedRect(
    414                   delegated_frame_to_target_transform,
    415                   output_shared_quad_state->clip_rect);
    416         } else {
    417           gfx::Rect clip_rect = drawable_content_rect();
    418           if (output_shared_quad_state->is_clipped) {
    419             clip_rect.Intersect(MathUtil::MapEnclosingClippedRect(
    420                 delegated_frame_to_target_transform,
    421                 output_shared_quad_state->clip_rect));
    422           }
    423           output_shared_quad_state->clip_rect = clip_rect;
    424           output_shared_quad_state->is_clipped = true;
    425         }
    426 
    427         output_shared_quad_state->opacity *= draw_opacity();
    428       }
    429     }
    430     DCHECK(output_shared_quad_state);
    431 
    432     gfx::Transform quad_content_to_delegated_target_space =
    433         output_shared_quad_state->content_to_target_transform;
    434     if (!is_root_delegated_render_pass) {
    435       quad_content_to_delegated_target_space.ConcatTransform(
    436           quad_sink->render_pass()->transform_to_root_target);
    437       quad_content_to_delegated_target_space.ConcatTransform(draw_transform());
    438     }
    439 
    440     gfx::Rect quad_visible_rect = quad_sink->UnoccludedContentRect(
    441         delegated_quad->visible_rect, quad_content_to_delegated_target_space);
    442 
    443     if (quad_visible_rect.IsEmpty())
    444       continue;
    445 
    446     scoped_ptr<DrawQuad> output_quad;
    447     if (delegated_quad->material != DrawQuad::RENDER_PASS) {
    448       output_quad = delegated_quad->Copy(output_shared_quad_state);
    449       output_quad->visible_rect = quad_visible_rect;
    450     } else {
    451       RenderPass::Id delegated_contributing_render_pass_id =
    452           RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id;
    453       RenderPass::Id output_contributing_render_pass_id(-1, -1);
    454 
    455       bool present =
    456           ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id,
    457                                        &output_contributing_render_pass_id);
    458 
    459       // The frame may have a RenderPassDrawQuad that points to a RenderPass not
    460       // part of the frame. Just ignore these quads.
    461       if (present) {
    462         DCHECK(output_contributing_render_pass_id !=
    463                append_quads_data->render_pass_id);
    464 
    465         output_quad = RenderPassDrawQuad::MaterialCast(delegated_quad)->Copy(
    466             output_shared_quad_state,
    467             output_contributing_render_pass_id).PassAs<DrawQuad>();
    468         output_quad->visible_rect = quad_visible_rect;
    469       }
    470     }
    471 
    472     if (output_quad)
    473       quad_sink->Append(output_quad.Pass());
    474   }
    475 }
    476 
    477 const char* DelegatedRendererLayerImpl::LayerTypeAsString() const {
    478   return "cc::DelegatedRendererLayerImpl";
    479 }
    480 
    481 void DelegatedRendererLayerImpl::ClearChildId() {
    482   if (!child_id_)
    483     return;
    484 
    485   if (own_child_id_) {
    486     ResourceProvider* provider = layer_tree_impl()->resource_provider();
    487     provider->DestroyChild(child_id_);
    488   }
    489 
    490   resources_.clear();
    491   child_id_ = 0;
    492 }
    493 
    494 }  // namespace cc
    495