cc/surfaces/surface_manager.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_manager.h"
   6
   7 #include "base/logging.h"
   8 #include "cc/surfaces/surface.h"
   9 #include "cc/surfaces/surface_id_allocator.h"
  10
  11 namespace cc {
  12
  13 SurfaceManager::SurfaceManager() {
  14   thread_checker_.DetachFromThread();
  15 }
  16
  17 SurfaceManager::~SurfaceManager() {
  18   DCHECK(thread_checker_.CalledOnValidThread());
  19   for (SurfaceDestroyList::iterator it = surfaces_to_destroy_.begin();
  20        it != surfaces_to_destroy_.end();
  21        ++it) {
  22     DeregisterSurface((*it)->surface_id());
  23     delete *it;
  24   }
  25 }
  26
  27 void SurfaceManager::RegisterSurface(Surface* surface) {
  28   DCHECK(thread_checker_.CalledOnValidThread());
  29   DCHECK(surface);
  30   DCHECK(!surface_map_.count(surface->surface_id()));
  31   surface_map_[surface->surface_id()] = surface;
  32 }
  33
  34 void SurfaceManager::DeregisterSurface(SurfaceId surface_id) {
  35   DCHECK(thread_checker_.CalledOnValidThread());
  36   SurfaceMap::iterator it = surface_map_.find(surface_id);
  37   DCHECK(it != surface_map_.end());
  38   surface_map_.erase(it);
  39 }
  40
  41 void SurfaceManager::Destroy(scoped_ptr<Surface> surface) {
  42   DCHECK(thread_checker_.CalledOnValidThread());
  43   surfaces_to_destroy_.push_back(surface.release());
  44   SearchForSatisfaction();
  45 }
  46
  47 void SurfaceManager::DidSatisfySequences(uint32_t id_namespace,
  48                                          std::vector<uint32_t>* sequence) {
  49   DCHECK(thread_checker_.CalledOnValidThread());
  50   for (std::vector<uint32_t>::iterator it = sequence->begin();
  51        it != sequence->end();
  52        ++it) {
  53     satisfied_sequences_.insert(SurfaceSequence(id_namespace, *it));
  54   }
  55   sequence->clear();
  56   SearchForSatisfaction();
  57 }
  58
  59 void SurfaceManager::RegisterSurfaceIdNamespace(uint32_t id_namespace) {
  60   bool inserted = valid_surface_id_namespaces_.insert(id_namespace).second;
  61   DCHECK(inserted);
  62 }
  63
  64 void SurfaceManager::InvalidateSurfaceIdNamespace(uint32_t id_namespace) {
  65   valid_surface_id_namespaces_.erase(id_namespace);
  66   SearchForSatisfaction();
  67 }
  68
  69 void SurfaceManager::SearchForSatisfaction() {
  70   for (SurfaceDestroyList::iterator dest_it = surfaces_to_destroy_.begin();
  71        dest_it != surfaces_to_destroy_.end();) {
  72     (*dest_it)->SatisfyDestructionDependencies(&satisfied_sequences_,
  73                                                &valid_surface_id_namespaces_);
  74     if (!(*dest_it)->GetDestructionDependencyCount()) {
  75       scoped_ptr<Surface> surf(*dest_it);
  76       DeregisterSurface(surf->surface_id());
  77       dest_it = surfaces_to_destroy_.erase(dest_it);
  78     } else {
  79       ++dest_it;
  80     }
  81   }
  82 }
  83
  84 Surface* SurfaceManager::GetSurfaceForId(SurfaceId surface_id) {
  85   DCHECK(thread_checker_.CalledOnValidThread());
  86   SurfaceMap::iterator it = surface_map_.find(surface_id);
  87   if (it == surface_map_.end())
  88     return NULL;
  89   return it->second;
  90 }
  91
  92 bool SurfaceManager::SurfaceModified(SurfaceId surface_id) {
  93   DCHECK(thread_checker_.CalledOnValidThread());
  94   bool changed = false;
  95   FOR_EACH_OBSERVER(SurfaceDamageObserver, observer_list_,
  96                     OnSurfaceDamaged(surface_id, &changed));
  97   return changed;
  98 }
  99
 100 }  // namespace cc