blob: 9ba2eea2543043d8f7d06e6a5c9738185924b25d [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.
#ifndef CC_SURFACES_SURFACE_MANAGER_H_
#define CC_SURFACES_SURFACE_MANAGER_H_
#include <stdint.h>
#include <list>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "base/macros.h"
#include "base/observer_list.h"
#include "base/threading/thread_checker.h"
#include "cc/surfaces/frame_sink_id.h"
#include "cc/surfaces/surface_id.h"
#include "cc/surfaces/surface_observer.h"
#include "cc/surfaces/surface_sequence.h"
#include "cc/surfaces/surfaces_export.h"
namespace cc {
class BeginFrameSource;
class CompositorFrame;
class Surface;
class SurfaceFactoryClient;
class CC_SURFACES_EXPORT SurfaceManager {
public:
SurfaceManager();
~SurfaceManager();
void RegisterSurface(Surface* surface);
void DeregisterSurface(const SurfaceId& surface_id);
// Destroy the Surface once a set of sequence numbers has been satisfied.
void Destroy(std::unique_ptr<Surface> surface);
Surface* GetSurfaceForId(const SurfaceId& surface_id);
void AddObserver(SurfaceObserver* obs) { observer_list_.AddObserver(obs); }
void RemoveObserver(SurfaceObserver* obs) {
observer_list_.RemoveObserver(obs);
}
bool SurfaceModified(const SurfaceId& surface_id);
// Called when a CompositorFrame is submitted to a SurfaceFactory for a given
// |surface_id| for the first time.
void SurfaceCreated(const SurfaceId& surface_id,
const gfx::Size& frame_size,
float device_scale_factor);
// A frame for a surface satisfies a set of sequence numbers in a particular
// id namespace.
void DidSatisfySequences(const FrameSinkId& frame_sink_id,
std::vector<uint32_t>* sequence);
void RegisterFrameSinkId(const FrameSinkId& frame_sink_id);
// Invalidate a frame_sink_id that might still have associated sequences,
// possibly because a renderer process has crashed.
void InvalidateFrameSinkId(const FrameSinkId& frame_sink_id);
// SurfaceFactoryClient, hierarchy, and BeginFrameSource can be registered
// and unregistered in any order with respect to each other.
//
// This happens in practice, e.g. the relationship to between ui::Compositor /
// DelegatedFrameHost is known before ui::Compositor has a surface/client).
// However, DelegatedFrameHost can register itself as a client before its
// relationship with the ui::Compositor is known.
// Associates a SurfaceFactoryClient with the surface id frame_sink_id it
// uses.
// SurfaceFactoryClient and surface namespaces/allocators have a 1:1 mapping.
// Caller guarantees the client is alive between register/unregister.
// Reregistering the same namespace when a previous client is active is not
// valid.
void RegisterSurfaceFactoryClient(const FrameSinkId& frame_sink_id,
SurfaceFactoryClient* client);
void UnregisterSurfaceFactoryClient(const FrameSinkId& frame_sink_id);
// Associates a |source| with a particular namespace. That namespace and
// any children of that namespace with valid clients can potentially use
// that |source|.
void RegisterBeginFrameSource(BeginFrameSource* source,
const FrameSinkId& frame_sink_id);
void UnregisterBeginFrameSource(BeginFrameSource* source);
// Register a relationship between two namespaces. This relationship means
// that surfaces from the child namespace will be displayed in the parent.
// Children are allowed to use any begin frame source that their parent can
// use.
void RegisterFrameSinkHierarchy(const FrameSinkId& parent_frame_sink_id,
const FrameSinkId& child_frame_sink_id);
void UnregisterFrameSinkHierarchy(const FrameSinkId& parent_frame_sink_id,
const FrameSinkId& child_frame_sink_id);
private:
void RecursivelyAttachBeginFrameSource(const FrameSinkId& frame_sink_id,
BeginFrameSource* source);
void RecursivelyDetachBeginFrameSource(const FrameSinkId& frame_sink_id,
BeginFrameSource* source);
// Returns true if |child namespace| is or has |search_frame_sink_id| as a
// child.
bool ChildContains(const FrameSinkId& child_frame_sink_id,
const FrameSinkId& search_frame_sink_id) const;
void GarbageCollectSurfaces();
using SurfaceMap = std::unordered_map<SurfaceId, Surface*, SurfaceIdHash>;
SurfaceMap surface_map_;
base::ObserverList<SurfaceObserver> observer_list_;
base::ThreadChecker thread_checker_;
// List of surfaces to be destroyed, along with what sequences they're still
// waiting on.
using SurfaceDestroyList = std::list<std::unique_ptr<Surface>>;
SurfaceDestroyList surfaces_to_destroy_;
// Set of SurfaceSequences that have been satisfied by a frame but not yet
// waited on.
std::unordered_set<SurfaceSequence, SurfaceSequenceHash> satisfied_sequences_;
// Set of valid surface ID namespaces. When a namespace is removed from
// this set, any remaining sequences with that namespace are considered
// satisfied.
std::unordered_set<FrameSinkId, FrameSinkIdHash> valid_frame_sink_ids_;
// Begin frame source routing. Both BeginFrameSource and SurfaceFactoryClient
// pointers guaranteed alive by callers until unregistered.
struct FrameSinkSourceMapping {
FrameSinkSourceMapping();
FrameSinkSourceMapping(const FrameSinkSourceMapping& other);
~FrameSinkSourceMapping();
bool is_empty() const { return !client && children.empty(); }
// The client that's responsible for creating this namespace. Never null.
SurfaceFactoryClient* client;
// The currently assigned begin frame source for this client.
BeginFrameSource* source;
// This represents a dag of parent -> children mapping.
std::vector<FrameSinkId> children;
};
std::unordered_map<FrameSinkId, FrameSinkSourceMapping, FrameSinkIdHash>
frame_sink_source_map_;
// Set of which sources are registered to which namespace. Any child
// that is implicitly using this namespace must be reachable by the
// parent in the dag.
std::unordered_map<BeginFrameSource*, FrameSinkId> registered_sources_;
DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
};
} // namespace cc
#endif // CC_SURFACES_SURFACE_MANAGER_H_