| // Copyright 2016 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 CompositorMutatorImpl_h |
| #define CompositorMutatorImpl_h |
| |
| #include <memory> |
| |
| #include "base/macros.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/single_thread_task_runner.h" |
| #include "platform/graphics/CompositorAnimator.h" |
| #include "platform/graphics/CompositorMutator.h" |
| #include "platform/heap/Handle.h" |
| #include "platform/heap/Persistent.h" |
| #include "platform/heap/Visitor.h" |
| #include "platform/wtf/HashSet.h" |
| |
| namespace blink { |
| |
| class CompositorMutatorClient; |
| class WaitableEvent; |
| |
| // Fans out requests from the compositor to all of the registered |
| // CompositorAnimators which can then mutate layers through their respective |
| // mutate interface. Requests for animation frames are received from |
| // CompositorAnimators and sent to the compositor to generate a new compositor |
| // frame. |
| // |
| // Unless otherwise noted, this should be accessed only on the compositor |
| // thread. |
| class PLATFORM_EXPORT CompositorMutatorImpl final : public CompositorMutator { |
| public: |
| // There are three outputs for the two interface surfaces of the created |
| // class blob. The returned owning pointer to the Client, which |
| // also owns the rest of the structure. |mutatee| and |mutatee_runner| form a |
| // pair for referencing the CompositorMutatorImpl. i.e. Put tasks on the |
| // TaskRunner using the WeakPtr to get to the methods. |
| static std::unique_ptr<CompositorMutatorClient> CreateClient( |
| base::WeakPtr<CompositorMutatorImpl>* mutatee, |
| scoped_refptr<base::SingleThreadTaskRunner>* mutatee_runner); |
| |
| CompositorMutatorImpl(); |
| ~CompositorMutatorImpl(); |
| |
| // CompositorMutator implementation. |
| void Mutate(std::unique_ptr<CompositorMutatorInputState>) override; |
| // TODO(majidvp): Remove when timeline inputs are known. |
| bool HasAnimators() override; |
| |
| // Interface for use by the AnimationWorklet Thread(s) to request calls. |
| // (To the given Animator on the given TaskRunner.) |
| void RegisterCompositorAnimator( |
| CrossThreadPersistent<CompositorAnimator>, |
| scoped_refptr<base::SingleThreadTaskRunner> animator_runner); |
| |
| void UnregisterCompositorAnimator(CrossThreadPersistent<CompositorAnimator>); |
| |
| void SetClient(CompositorMutatorClient* client) { client_ = client; } |
| |
| private: |
| using CompositorAnimators = |
| HashSet<CrossThreadPersistent<CompositorAnimator>>; |
| |
| class AutoSignal { |
| WTF_MAKE_NONCOPYABLE(AutoSignal); |
| |
| public: |
| explicit AutoSignal(WaitableEvent*); |
| ~AutoSignal(); |
| |
| private: |
| WaitableEvent* event_; |
| }; |
| |
| // The AnimationWorkletProxyClientImpls are also owned by the WorkerClients |
| // dictionary. |
| CompositorAnimators animators_; |
| |
| scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() { |
| return mutator_queue_; |
| } |
| |
| scoped_refptr<base::SingleThreadTaskRunner> mutator_queue_; |
| |
| // Currently we only support a single queue for animators. |
| scoped_refptr<base::SingleThreadTaskRunner> animator_queue_; |
| |
| // The CompositorMutatorClient owns (std::unique_ptr) us, so this pointer is |
| // valid as long as this class exists. |
| CompositorMutatorClient* client_; |
| |
| base::WeakPtrFactory<CompositorMutatorImpl> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(CompositorMutatorImpl); |
| }; |
| |
| } // namespace blink |
| |
| #endif // CompositorMutatorImpl_h |