cc/surfaces/surface_aggregator.cc

   1 // Copyright 2014 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/surfaces/surface_aggregator.h"
   6
   7 #include <map>
   8
   9 #include "base/bind.h"
  10 #include "base/containers/hash_tables.h"
  11 #include "base/debug/trace_event.h"
  12 #include "base/logging.h"
  13 #include "cc/base/math_util.h"
  14 #include "cc/output/compositor_frame.h"
  15 #include "cc/output/delegated_frame_data.h"
  16 #include "cc/quads/draw_quad.h"
  17 #include "cc/quads/render_pass_draw_quad.h"
  18 #include "cc/quads/shared_quad_state.h"
  19 #include "cc/quads/surface_draw_quad.h"
  20 #include "cc/surfaces/surface.h"
  21 #include "cc/surfaces/surface_factory.h"
  22 #include "cc/surfaces/surface_manager.h"
  23 #include "cc/trees/blocking_task_runner.h"
  24
  25 namespace cc {
  26 namespace {
  27
  28 void MoveMatchingRequests(
  29     RenderPassId id,
  30     std::multimap<RenderPassId, CopyOutputRequest*>* copy_requests,
  31     ScopedPtrVector<CopyOutputRequest>* output_requests) {
  32   auto request_range = copy_requests->equal_range(id);
  33   for (auto it = request_range.first; it != request_range.second; ++it) {
  34     DCHECK(it->second);
  35     output_requests->push_back(scoped_ptr<CopyOutputRequest>(it->second));
  36     it->second = nullptr;
  37   }
  38   copy_requests->erase(request_range.first, request_range.second);
  39 }
  40
  41 }  // namespace
  42
  43 SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
  44                                      ResourceProvider* provider)
  45     : manager_(manager), provider_(provider), next_render_pass_id_(1) {
  46   DCHECK(manager_);
  47 }
  48
  49 SurfaceAggregator::~SurfaceAggregator() {}
  50
  51 class SurfaceAggregator::RenderPassIdAllocator {
  52  public:
  53   explicit RenderPassIdAllocator(int* next_index) : next_index_(next_index) {}
  54   ~RenderPassIdAllocator() {}
  55
  56   void AddKnownPass(RenderPassId id) {
  57     if (id_to_index_map_.find(id) != id_to_index_map_.end())
  58       return;
  59     id_to_index_map_[id] = (*next_index_)++;
  60   }
  61
  62   RenderPassId Remap(RenderPassId id) {
  63     DCHECK(id_to_index_map_.find(id) != id_to_index_map_.end());
  64     return RenderPassId(1, id_to_index_map_[id]);
  65   }
  66
  67  private:
  68   base::hash_map<RenderPassId, int> id_to_index_map_;
  69   int* next_index_;
  70
  71   DISALLOW_COPY_AND_ASSIGN(RenderPassIdAllocator);
  72 };
  73
  74 static void UnrefHelper(base::WeakPtr<SurfaceFactory> surface_factory,
  75                         const ReturnedResourceArray& resources,
  76                         BlockingTaskRunner* main_thread_task_runner) {
  77   if (surface_factory)
  78     surface_factory->UnrefResources(resources);
  79 }
  80
  81 RenderPassId SurfaceAggregator::RemapPassId(RenderPassId surface_local_pass_id,
  82                                             SurfaceId surface_id) {
  83   RenderPassIdAllocator* allocator = render_pass_allocator_map_.get(surface_id);
  84   if (!allocator) {
  85     allocator = new RenderPassIdAllocator(&next_render_pass_id_);
  86     render_pass_allocator_map_.set(surface_id, make_scoped_ptr(allocator));
  87   }
  88   allocator->AddKnownPass(surface_local_pass_id);
  89   return allocator->Remap(surface_local_pass_id);
  90 }
  91
  92 int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
  93   SurfaceToResourceChildIdMap::iterator it =
  94       surface_id_to_resource_child_id_.find(surface->surface_id());
  95   if (it == surface_id_to_resource_child_id_.end()) {
  96     int child_id =
  97         provider_->CreateChild(base::Bind(&UnrefHelper, surface->factory()));
  98     surface_id_to_resource_child_id_[surface->surface_id()] = child_id;
  99     return child_id;
 100   } else {
 101     return it->second;
 102   }
 103 }
 104
 105 static ResourceProvider::ResourceId ResourceRemapHelper(
 106     bool* invalid_frame,
 107     const ResourceProvider::ResourceIdMap& child_to_parent_map,
 108     ResourceProvider::ResourceIdArray* resources_in_frame,
 109     ResourceProvider::ResourceId id) {
 110   ResourceProvider::ResourceIdMap::const_iterator it =
 111       child_to_parent_map.find(id);
 112   if (it == child_to_parent_map.end()) {
 113     *invalid_frame = true;
 114     return 0;
 115   }
 116
 117   DCHECK_EQ(it->first, id);
 118   ResourceProvider::ResourceId remapped_id = it->second;
 119   resources_in_frame->push_back(id);
 120   return remapped_id;
 121 }
 122
 123 bool SurfaceAggregator::TakeResources(Surface* surface,
 124                                       const DelegatedFrameData* frame_data,
 125                                       RenderPassList* render_pass_list) {
 126   RenderPass::CopyAll(frame_data->render_pass_list, render_pass_list);
 127   if (!provider_)  // TODO(jamesr): hack for unit tests that don't set up rp
 128     return false;
 129
 130   int child_id = ChildIdForSurface(surface);
 131   provider_->ReceiveFromChild(child_id, frame_data->resource_list);
 132   if (surface->factory())
 133     surface->factory()->RefResources(frame_data->resource_list);
 134
 135   typedef ResourceProvider::ResourceIdArray IdArray;
 136   IdArray referenced_resources;
 137
 138   bool invalid_frame = false;
 139   DrawQuad::ResourceIteratorCallback remap =
 140       base::Bind(&ResourceRemapHelper,
 141                  &invalid_frame,
 142                  provider_->GetChildToParentMap(child_id),
 143                  &referenced_resources);
 144   for (const auto& render_pass : *render_pass_list) {
 145     for (const auto& quad : render_pass->quad_list)
 146       quad->IterateResources(remap);
 147   }
 148
 149   if (!invalid_frame)
 150     provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
 151
 152   return invalid_frame;
 153 }
 154
 155 gfx::Rect SurfaceAggregator::DamageRectForSurface(const Surface* surface,
 156                                                   const RenderPass& source) {
 157   int previous_index = previous_contained_surfaces_[surface->surface_id()];
 158   if (previous_index == surface->frame_index())
 159     return gfx::Rect();
 160   else if (previous_index == surface->frame_index() - 1)
 161     return source.damage_rect;
 162   return gfx::Rect(surface->size());
 163 }
 164
 165 void SurfaceAggregator::HandleSurfaceQuad(const SurfaceDrawQuad* surface_quad,
 166                                           RenderPass* dest_pass) {
 167   SurfaceId surface_id = surface_quad->surface_id;
 168   // If this surface's id is already in our referenced set then it creates
 169   // a cycle in the graph and should be dropped.
 170   if (referenced_surfaces_.count(surface_id))
 171     return;
 172   Surface* surface = manager_->GetSurfaceForId(surface_id);
 173   if (!surface) {
 174     contained_surfaces_[surface_id] = 0;
 175     return;
 176   }
 177   contained_surfaces_[surface_id] = surface->frame_index();
 178   const CompositorFrame* frame = surface->GetEligibleFrame();
 179   if (!frame)
 180     return;
 181   const DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
 182   if (!frame_data)
 183     return;
 184
 185   std::multimap<RenderPassId, CopyOutputRequest*> copy_requests;
 186   surface->TakeCopyOutputRequests(&copy_requests);
 187
 188   RenderPassList render_pass_list;
 189   bool invalid_frame = TakeResources(surface, frame_data, &render_pass_list);
 190   if (invalid_frame) {
 191     for (auto& request : copy_requests) {
 192       request.second->SendEmptyResult();
 193       delete request.second;
 194     }
 195     return;
 196   }
 197
 198   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
 199
 200   bool merge_pass = copy_requests.empty();
 201
 202   const RenderPassList& referenced_passes = render_pass_list;
 203   size_t passes_to_copy =
 204       merge_pass ? referenced_passes.size() - 1 : referenced_passes.size();
 205   for (size_t j = 0; j < passes_to_copy; ++j) {
 206     const RenderPass& source = *referenced_passes[j];
 207
 208     size_t sqs_size = source.shared_quad_state_list.size();
 209     size_t dq_size = source.quad_list.size();
 210     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 211
 212     RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 213
 214     copy_pass->SetAll(remapped_pass_id,
 215                       source.output_rect,
 216                       source.damage_rect,
 217                       source.transform_to_root_target,
 218                       source.has_transparent_background);
 219
 220     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 221
 222     // Contributing passes aggregated in to the pass list need to take the
 223     // transform of the surface quad into account to update their transform to
 224     // the root surface.
 225     // TODO(jamesr): Make sure this is sufficient for surfaces nested several
 226     // levels deep and add tests.
 227     copy_pass->transform_to_root_target.ConcatTransform(
 228         surface_quad->quadTransform());
 229
 230     CopyQuadsToPass(source.quad_list,
 231                     source.shared_quad_state_list,
 232                     gfx::Transform(),
 233                     copy_pass.get(),
 234                     surface_id);
 235
 236     dest_pass_list_->push_back(copy_pass.Pass());
 237   }
 238
 239   const RenderPass& last_pass = *render_pass_list.back();
 240   if (merge_pass) {
 241     // TODO(jamesr): Clean up last pass special casing.
 242     const QuadList& quads = last_pass.quad_list;
 243
 244     // TODO(jamesr): Make sure clipping is enforced.
 245     CopyQuadsToPass(quads,
 246                     last_pass.shared_quad_state_list,
 247                     surface_quad->quadTransform(),
 248                     dest_pass,
 249                     surface_id);
 250   } else {
 251     RenderPassId remapped_pass_id = RemapPassId(last_pass.id, surface_id);
 252
 253     SharedQuadState* shared_quad_state =
 254         dest_pass->CreateAndAppendSharedQuadState();
 255     shared_quad_state->CopyFrom(surface_quad->shared_quad_state);
 256     RenderPassDrawQuad* quad =
 257         dest_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
 258     quad->SetNew(shared_quad_state,
 259                  surface_quad->rect,
 260                  surface_quad->visible_rect,
 261                  remapped_pass_id,
 262                  0,
 263                  gfx::Vector2dF(),
 264                  gfx::Size(),
 265                  FilterOperations(),
 266                  gfx::Vector2dF(),
 267                  FilterOperations());
 268   }
 269   dest_pass->damage_rect =
 270       gfx::UnionRects(dest_pass->damage_rect,
 271                       MathUtil::MapEnclosingClippedRect(
 272                           surface_quad->quadTransform(),
 273                           DamageRectForSurface(surface, last_pass)));
 274
 275   referenced_surfaces_.erase(it);
 276 }
 277
 278 void SurfaceAggregator::CopySharedQuadState(
 279     const SharedQuadState* source_sqs,
 280     const gfx::Transform& content_to_target_transform,
 281     RenderPass* dest_render_pass) {
 282   SharedQuadState* copy_shared_quad_state =
 283       dest_render_pass->CreateAndAppendSharedQuadState();
 284   copy_shared_quad_state->CopyFrom(source_sqs);
 285   // content_to_target_transform contains any transformation that may exist
 286   // between the context that these quads are being copied from (i.e. the
 287   // surface's draw transform when aggregated from within a surface) to the
 288   // target space of the pass. This will be identity except when copying the
 289   // root draw pass from a surface into a pass when the surface draw quad's
 290   // transform is not identity.
 291   copy_shared_quad_state->content_to_target_transform.ConcatTransform(
 292       content_to_target_transform);
 293   if (copy_shared_quad_state->is_clipped) {
 294     copy_shared_quad_state->clip_rect = MathUtil::MapEnclosingClippedRect(
 295         content_to_target_transform, copy_shared_quad_state->clip_rect);
 296   }
 297 }
 298
 299 void SurfaceAggregator::CopyQuadsToPass(
 300     const QuadList& source_quad_list,
 301     const SharedQuadStateList& source_shared_quad_state_list,
 302     const gfx::Transform& content_to_target_transform,
 303     RenderPass* dest_pass,
 304     SurfaceId surface_id) {
 305   const SharedQuadState* last_copied_source_shared_quad_state = NULL;
 306
 307   SharedQuadStateList::ConstIterator sqs_iter =
 308       source_shared_quad_state_list.begin();
 309   for (const auto& quad : source_quad_list) {
 310     while (quad->shared_quad_state != *sqs_iter) {
 311       ++sqs_iter;
 312       DCHECK(sqs_iter != source_shared_quad_state_list.end());
 313     }
 314     DCHECK_EQ(quad->shared_quad_state, *sqs_iter);
 315
 316     if (quad->material == DrawQuad::SURFACE_CONTENT) {
 317       const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
 318       HandleSurfaceQuad(surface_quad, dest_pass);
 319     } else {
 320       if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
 321         CopySharedQuadState(
 322             quad->shared_quad_state, content_to_target_transform, dest_pass);
 323         last_copied_source_shared_quad_state = quad->shared_quad_state;
 324       }
 325       if (quad->material == DrawQuad::RENDER_PASS) {
 326         const RenderPassDrawQuad* pass_quad =
 327             RenderPassDrawQuad::MaterialCast(quad);
 328         RenderPassId original_pass_id = pass_quad->render_pass_id;
 329         RenderPassId remapped_pass_id =
 330             RemapPassId(original_pass_id, surface_id);
 331
 332         dest_pass->CopyFromAndAppendRenderPassDrawQuad(
 333             pass_quad,
 334             dest_pass->shared_quad_state_list.back(),
 335             remapped_pass_id);
 336       } else {
 337         dest_pass->CopyFromAndAppendDrawQuad(
 338             quad, dest_pass->shared_quad_state_list.back());
 339       }
 340     }
 341   }
 342 }
 343
 344 void SurfaceAggregator::CopyPasses(const DelegatedFrameData* frame_data,
 345                                    Surface* surface) {
 346   RenderPassList source_pass_list;
 347
 348   // The root surface is allowed to have copy output requests, so grab them
 349   // off its render passes.
 350   std::multimap<RenderPassId, CopyOutputRequest*> copy_requests;
 351   surface->TakeCopyOutputRequests(&copy_requests);
 352
 353   bool invalid_frame = TakeResources(surface, frame_data, &source_pass_list);
 354   DCHECK(!invalid_frame);
 355
 356   for (size_t i = 0; i < source_pass_list.size(); ++i) {
 357     const RenderPass& source = *source_pass_list[i];
 358
 359     size_t sqs_size = source.shared_quad_state_list.size();
 360     size_t dq_size = source.quad_list.size();
 361     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 362
 363     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 364
 365     RenderPassId remapped_pass_id =
 366         RemapPassId(source.id, surface->surface_id());
 367
 368     copy_pass->SetAll(remapped_pass_id,
 369                       source.output_rect,
 370                       DamageRectForSurface(surface, source),
 371                       source.transform_to_root_target,
 372                       source.has_transparent_background);
 373
 374     CopyQuadsToPass(source.quad_list,
 375                     source.shared_quad_state_list,
 376                     gfx::Transform(),
 377                     copy_pass.get(),
 378                     surface->surface_id());
 379
 380     dest_pass_list_->push_back(copy_pass.Pass());
 381   }
 382 }
 383
 384 scoped_ptr<CompositorFrame> SurfaceAggregator::Aggregate(SurfaceId surface_id) {
 385   Surface* surface = manager_->GetSurfaceForId(surface_id);
 386   DCHECK(surface);
 387   contained_surfaces_[surface_id] = surface->frame_index();
 388   const CompositorFrame* root_surface_frame = surface->GetEligibleFrame();
 389   if (!root_surface_frame)
 390     return nullptr;
 391   TRACE_EVENT0("cc", "SurfaceAggregator::Aggregate");
 392
 393   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
 394   frame->delegated_frame_data = make_scoped_ptr(new DelegatedFrameData);
 395
 396   DCHECK(root_surface_frame->delegated_frame_data);
 397
 398   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
 399
 400   dest_resource_list_ = &frame->delegated_frame_data->resource_list;
 401   dest_pass_list_ = &frame->delegated_frame_data->render_pass_list;
 402
 403   CopyPasses(root_surface_frame->delegated_frame_data.get(), surface);
 404
 405   referenced_surfaces_.erase(it);
 406   DCHECK(referenced_surfaces_.empty());
 407
 408   dest_pass_list_ = NULL;
 409   contained_surfaces_.swap(previous_contained_surfaces_);
 410   contained_surfaces_.clear();
 411
 412   for (SurfaceIndexMap::iterator it = previous_contained_surfaces_.begin();
 413        it != previous_contained_surfaces_.end();
 414        ++it) {
 415     Surface* surface = manager_->GetSurfaceForId(it->first);
 416     if (surface)
 417       surface->TakeLatencyInfo(&frame->metadata.latency_info);
 418   }
 419
 420   // TODO(jamesr): Aggregate all resource references into the returned frame's
 421   // resource list.
 422
 423   return frame.Pass();
 424 }
 425
 426 }  // namespace cc