src/cc/layers/delegated_renderer_layer_impl.cc

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