blob: e34bb63a40970e6632440d6c40eede3b1f5e61b1 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/surfaces/surface_manager.h"
#include <stddef.h>
#include <stdint.h>
#include "base/logging.h"
#include "cc/surfaces/surface.h"
#include "cc/surfaces/surface_factory_client.h"
#include "cc/surfaces/surface_id_allocator.h"
namespace cc {
SurfaceManager::ClientSourceMapping::ClientSourceMapping()
: client(nullptr), source(nullptr) {}
SurfaceManager::ClientSourceMapping::ClientSourceMapping(
const ClientSourceMapping& other) = default;
SurfaceManager::ClientSourceMapping::~ClientSourceMapping() {
DCHECK(is_empty()) << "client: " << client
<< ", children: " << children.size();
}
SurfaceManager::SurfaceManager() {
thread_checker_.DetachFromThread();
}
SurfaceManager::~SurfaceManager() {
DCHECK(thread_checker_.CalledOnValidThread());
for (SurfaceDestroyList::iterator it = surfaces_to_destroy_.begin();
it != surfaces_to_destroy_.end();
++it) {
DeregisterSurface((*it)->surface_id());
}
surfaces_to_destroy_.clear();
// All hierarchies, sources, and surface factory clients should be
// unregistered prior to SurfaceManager destruction.
DCHECK_EQ(namespace_client_map_.size(), 0u);
DCHECK_EQ(registered_sources_.size(), 0u);
}
void SurfaceManager::RegisterSurface(Surface* surface) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(surface);
DCHECK(!surface_map_.count(surface->surface_id()));
surface_map_[surface->surface_id()] = surface;
}
void SurfaceManager::DeregisterSurface(const SurfaceId& surface_id) {
DCHECK(thread_checker_.CalledOnValidThread());
SurfaceMap::iterator it = surface_map_.find(surface_id);
DCHECK(it != surface_map_.end());
surface_map_.erase(it);
}
void SurfaceManager::Destroy(std::unique_ptr<Surface> surface) {
DCHECK(thread_checker_.CalledOnValidThread());
surface->set_destroyed(true);
surfaces_to_destroy_.push_back(std::move(surface));
GarbageCollectSurfaces();
}
void SurfaceManager::DidSatisfySequences(uint32_t client_id,
std::vector<uint32_t>* sequence) {
DCHECK(thread_checker_.CalledOnValidThread());
for (std::vector<uint32_t>::iterator it = sequence->begin();
it != sequence->end();
++it) {
satisfied_sequences_.insert(SurfaceSequence(client_id, *it));
}
sequence->clear();
GarbageCollectSurfaces();
}
void SurfaceManager::RegisterSurfaceClientId(uint32_t client_id) {
bool inserted = valid_surface_client_ids_.insert(client_id).second;
DCHECK(inserted);
}
void SurfaceManager::InvalidateSurfaceClientId(uint32_t client_id) {
valid_surface_client_ids_.erase(client_id);
GarbageCollectSurfaces();
}
void SurfaceManager::GarbageCollectSurfaces() {
// Simple mark and sweep GC.
// TODO(jbauman): Reduce the amount of work when nothing needs to be
// destroyed.
std::vector<SurfaceId> live_surfaces;
std::set<SurfaceId> live_surfaces_set;
// GC roots are surfaces that have not been destroyed, or have not had all
// their destruction dependencies satisfied.
for (auto& map_entry : surface_map_) {
map_entry.second->SatisfyDestructionDependencies(
&satisfied_sequences_, &valid_surface_client_ids_);
if (!map_entry.second->destroyed() ||
map_entry.second->GetDestructionDependencyCount()) {
live_surfaces_set.insert(map_entry.first);
live_surfaces.push_back(map_entry.first);
}
}
// Mark all surfaces reachable from live surfaces by adding them to
// live_surfaces and live_surfaces_set.
for (size_t i = 0; i < live_surfaces.size(); i++) {
Surface* surf = surface_map_[live_surfaces[i]];
DCHECK(surf);
for (const SurfaceId& id : surf->referenced_surfaces()) {
if (live_surfaces_set.count(id))
continue;
Surface* surf2 = GetSurfaceForId(id);
if (surf2) {
live_surfaces.push_back(id);
live_surfaces_set.insert(id);
}
}
}
std::vector<std::unique_ptr<Surface>> to_destroy;
// Destroy all remaining unreachable surfaces.
for (SurfaceDestroyList::iterator dest_it = surfaces_to_destroy_.begin();
dest_it != surfaces_to_destroy_.end();) {
if (!live_surfaces_set.count((*dest_it)->surface_id())) {
std::unique_ptr<Surface> surf(std::move(*dest_it));
DeregisterSurface(surf->surface_id());
dest_it = surfaces_to_destroy_.erase(dest_it);
to_destroy.push_back(std::move(surf));
} else {
++dest_it;
}
}
to_destroy.clear();
}
void SurfaceManager::RegisterSurfaceFactoryClient(
uint32_t client_id,
SurfaceFactoryClient* client) {
DCHECK(client);
DCHECK(!namespace_client_map_[client_id].client);
DCHECK_EQ(valid_surface_client_ids_.count(client_id), 1u);
auto iter = namespace_client_map_.find(client_id);
if (iter == namespace_client_map_.end()) {
auto insert_result = namespace_client_map_.insert(
std::make_pair(client_id, ClientSourceMapping()));
DCHECK(insert_result.second);
iter = insert_result.first;
}
iter->second.client = client;
// Propagate any previously set sources to the new client.
if (iter->second.source)
client->SetBeginFrameSource(iter->second.source);
}
void SurfaceManager::UnregisterSurfaceFactoryClient(uint32_t client_id) {
DCHECK_EQ(valid_surface_client_ids_.count(client_id), 1u);
DCHECK_EQ(namespace_client_map_.count(client_id), 1u);
auto iter = namespace_client_map_.find(client_id);
if (iter->second.source)
iter->second.client->SetBeginFrameSource(nullptr);
iter->second.client = nullptr;
// The SurfaceFactoryClient and hierarchy can be registered/unregistered
// in either order, so empty namespace_client_map entries need to be
// checked when removing either clients or relationships.
if (iter->second.is_empty())
namespace_client_map_.erase(iter);
}
void SurfaceManager::RegisterBeginFrameSource(BeginFrameSource* source,
uint32_t client_id) {
DCHECK(source);
DCHECK_EQ(registered_sources_.count(source), 0u);
DCHECK_EQ(valid_surface_client_ids_.count(client_id), 1u);
registered_sources_[source] = client_id;
RecursivelyAttachBeginFrameSource(client_id, source);
}
void SurfaceManager::UnregisterBeginFrameSource(BeginFrameSource* source) {
DCHECK(source);
DCHECK_EQ(registered_sources_.count(source), 1u);
uint32_t client_id = registered_sources_[source];
registered_sources_.erase(source);
if (namespace_client_map_.count(client_id) == 0u)
return;
// TODO(enne): these walks could be done in one step.
// Remove this begin frame source from its subtree.
RecursivelyDetachBeginFrameSource(client_id, source);
// Then flush every remaining registered source to fix any sources that
// became null because of the previous step but that have an alternative.
for (auto source_iter : registered_sources_)
RecursivelyAttachBeginFrameSource(source_iter.second, source_iter.first);
}
void SurfaceManager::RecursivelyAttachBeginFrameSource(
uint32_t client_id,
BeginFrameSource* source) {
ClientSourceMapping& mapping = namespace_client_map_[client_id];
if (!mapping.source) {
mapping.source = source;
if (mapping.client)
mapping.client->SetBeginFrameSource(source);
}
for (size_t i = 0; i < mapping.children.size(); ++i)
RecursivelyAttachBeginFrameSource(mapping.children[i], source);
}
void SurfaceManager::RecursivelyDetachBeginFrameSource(
uint32_t client_id,
BeginFrameSource* source) {
auto iter = namespace_client_map_.find(client_id);
if (iter == namespace_client_map_.end())
return;
if (iter->second.source == source) {
iter->second.source = nullptr;
if (iter->second.client)
iter->second.client->SetBeginFrameSource(nullptr);
}
if (iter->second.is_empty()) {
namespace_client_map_.erase(iter);
return;
}
std::vector<uint32_t>& children = iter->second.children;
for (size_t i = 0; i < children.size(); ++i) {
RecursivelyDetachBeginFrameSource(children[i], source);
}
}
bool SurfaceManager::ChildContains(uint32_t child_namespace,
uint32_t search_namespace) const {
auto iter = namespace_client_map_.find(child_namespace);
if (iter == namespace_client_map_.end())
return false;
const std::vector<uint32_t>& children = iter->second.children;
for (size_t i = 0; i < children.size(); ++i) {
if (children[i] == search_namespace)
return true;
if (ChildContains(children[i], search_namespace))
return true;
}
return false;
}
void SurfaceManager::RegisterSurfaceNamespaceHierarchy(
uint32_t parent_namespace,
uint32_t child_namespace) {
DCHECK_EQ(valid_surface_client_ids_.count(parent_namespace), 1u);
DCHECK_EQ(valid_surface_client_ids_.count(child_namespace), 1u);
// If it's possible to reach the parent through the child's descendant chain,
// then this will create an infinite loop. Might as well just crash here.
CHECK(!ChildContains(child_namespace, parent_namespace));
std::vector<uint32_t>& children =
namespace_client_map_[parent_namespace].children;
for (size_t i = 0; i < children.size(); ++i)
DCHECK_NE(children[i], child_namespace);
children.push_back(child_namespace);
// If the parent has no source, then attaching it to this child will
// not change any downstream sources.
BeginFrameSource* parent_source =
namespace_client_map_[parent_namespace].source;
if (!parent_source)
return;
DCHECK_EQ(registered_sources_.count(parent_source), 1u);
RecursivelyAttachBeginFrameSource(child_namespace, parent_source);
}
void SurfaceManager::UnregisterSurfaceNamespaceHierarchy(
uint32_t parent_namespace,
uint32_t child_namespace) {
// Deliberately do not check validity of either parent or child namespace
// here. They were valid during the registration, so were valid at some
// point in time. This makes it possible to invalidate parent and child
// namespaces independently of each other and not have an ordering dependency
// of unregistering the hierarchy first before either of them.
DCHECK_EQ(namespace_client_map_.count(parent_namespace), 1u);
auto iter = namespace_client_map_.find(parent_namespace);
std::vector<uint32_t>& children = iter->second.children;
bool found_child = false;
for (size_t i = 0; i < children.size(); ++i) {
if (children[i] == child_namespace) {
found_child = true;
children[i] = children.back();
children.resize(children.size() - 1);
break;
}
}
DCHECK(found_child);
// The SurfaceFactoryClient and hierarchy can be registered/unregistered
// in either order, so empty namespace_client_map entries need to be
// checked when removing either clients or relationships.
if (iter->second.is_empty()) {
namespace_client_map_.erase(iter);
return;
}
// If the parent does not have a begin frame source, then disconnecting it
// will not change any of its children.
BeginFrameSource* parent_source = iter->second.source;
if (!parent_source)
return;
// TODO(enne): these walks could be done in one step.
RecursivelyDetachBeginFrameSource(child_namespace, parent_source);
for (auto source_iter : registered_sources_)
RecursivelyAttachBeginFrameSource(source_iter.second, source_iter.first);
}
Surface* SurfaceManager::GetSurfaceForId(const SurfaceId& surface_id) {
DCHECK(thread_checker_.CalledOnValidThread());
SurfaceMap::iterator it = surface_map_.find(surface_id);
if (it == surface_map_.end())
return NULL;
return it->second;
}
bool SurfaceManager::SurfaceModified(const SurfaceId& surface_id) {
CHECK(thread_checker_.CalledOnValidThread());
bool changed = false;
FOR_EACH_OBSERVER(SurfaceDamageObserver, observer_list_,
OnSurfaceDamaged(surface_id, &changed));
return changed;
}
} // namespace cc