| // 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_FACTORY_H_ |
| #define CC_SURFACES_SURFACE_FACTORY_H_ |
| |
| #include <memory> |
| #include <set> |
| |
| #include "base/callback_forward.h" |
| #include "base/macros.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/observer_list.h" |
| #include "cc/output/compositor_frame.h" |
| #include "cc/surfaces/surface_id.h" |
| #include "cc/surfaces/surface_resource_holder.h" |
| #include "cc/surfaces/surface_sequence.h" |
| #include "cc/surfaces/surfaces_export.h" |
| |
| namespace cc { |
| class CopyOutputRequest; |
| class Surface; |
| class SurfaceFactoryClient; |
| class SurfaceManager; |
| |
| // This class is used for creating surfaces and submitting compositor frames to |
| // them. Surfaces are created lazily each time SubmitCompositorFrame is |
| // called with a local frame id that is different from the last call. Only one |
| // surface is owned by this class at a time, and upon constructing a new surface |
| // the old one will be destructed. Resources submitted to surfaces created by a |
| // particular factory will be returned to that factory's client when they are no |
| // longer being used. This is the only class most users of surfaces will need to |
| // directly interact with. |
| class CC_SURFACES_EXPORT SurfaceFactory { |
| public: |
| using DrawCallback = base::Callback<void()>; |
| |
| SurfaceFactory(const FrameSinkId& frame_sink_id, |
| SurfaceManager* manager, |
| SurfaceFactoryClient* client); |
| ~SurfaceFactory(); |
| |
| const FrameSinkId& frame_sink_id() const { return frame_sink_id_; } |
| |
| // Destroys the current surface. You need to call this method before the |
| // factory is destroyed, or when you would like to get rid of the surface as |
| // soon as possible (otherwise, the next time you call SubmitCompositorFrame |
| // the old surface will be dealt with). |
| void EvictSurface(); |
| |
| // Destroys and disowns the current surface, and resets all resource |
| // references. This is useful when resources are invalid (e.g. lost context). |
| void Reset(); |
| |
| // Submits the frame to the current surface being managed by the factory if |
| // the local frame ids match, or creates a new surface with the given local |
| // frame id, destroys the old one, and submits the frame to this new surface. |
| // The frame can contain references to any surface, regardless of which |
| // factory owns it. The callback is called the first time this frame is used |
| // to draw, or if the frame is discarded. |
| void SubmitCompositorFrame(const LocalFrameId& local_frame_id, |
| CompositorFrame frame, |
| const DrawCallback& callback); |
| void RequestCopyOfSurface(std::unique_ptr<CopyOutputRequest> copy_request); |
| |
| // Evicts the current frame on the surface. All the resources |
| // will be released and Surface::HasFrame will return false. |
| void ClearSurface(); |
| |
| void WillDrawSurface(const LocalFrameId& id, const gfx::Rect& damage_rect); |
| |
| SurfaceFactoryClient* client() { return client_; } |
| |
| void ReceiveFromChild(const TransferableResourceArray& resources); |
| void RefResources(const TransferableResourceArray& resources); |
| void UnrefResources(const ReturnedResourceArray& resources); |
| |
| SurfaceManager* manager() { return manager_; } |
| |
| // This can be set to false if resources from this SurfaceFactory don't need |
| // to have sync points set on them when returned from the Display, for |
| // example if the Display shares a context with the creator. |
| bool needs_sync_points() const { return needs_sync_points_; } |
| void set_needs_sync_points(bool needs) { needs_sync_points_ = needs; } |
| |
| // SurfaceFactory's owner can call this when it finds out that SurfaceManager |
| // is no longer alive during destruction. |
| void DidDestroySurfaceManager() { manager_ = nullptr; } |
| |
| private: |
| std::unique_ptr<Surface> Create(const LocalFrameId& local_frame_id); |
| void Destroy(std::unique_ptr<Surface> surface); |
| |
| const FrameSinkId frame_sink_id_; |
| SurfaceManager* manager_; |
| SurfaceFactoryClient* client_; |
| SurfaceResourceHolder holder_; |
| bool needs_sync_points_; |
| std::unique_ptr<Surface> current_surface_; |
| base::WeakPtrFactory<SurfaceFactory> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(SurfaceFactory); |
| }; |
| |
| } // namespace cc |
| |
| #endif // CC_SURFACES_SURFACE_FACTORY_H_ |