1// Copyright 2011 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#ifndef CC_TREES_PROXY_H_ 6#define CC_TREES_PROXY_H_ 7 8#include <string> 9 10#include "base/basictypes.h" 11#include "base/logging.h" 12#include "base/memory/ref_counted.h" 13#include "base/memory/scoped_ptr.h" 14#include "base/threading/platform_thread.h" 15#include "base/time/time.h" 16#include "base/values.h" 17#include "cc/base/cc_export.h" 18 19namespace base { 20namespace debug { 21class TracedValue; 22} 23class SingleThreadTaskRunner; 24} 25 26namespace gfx { 27class Rect; 28class Vector2d; 29} 30 31namespace cc { 32class BlockingTaskRunner; 33class LayerTreeDebugState; 34class OutputSurface; 35struct RendererCapabilities; 36 37// Abstract class responsible for proxying commands from the main-thread side of 38// the compositor over to the compositor implementation. 39class CC_EXPORT Proxy { 40 public: 41 base::SingleThreadTaskRunner* MainThreadTaskRunner() const; 42 bool HasImplThread() const; 43 base::SingleThreadTaskRunner* ImplThreadTaskRunner() const; 44 45 // Debug hooks. 46 bool IsMainThread() const; 47 bool IsImplThread() const; 48 bool IsMainThreadBlocked() const; 49#if DCHECK_IS_ON 50 void SetMainThreadBlocked(bool is_main_thread_blocked); 51 void SetCurrentThreadIsImplThread(bool is_impl_thread); 52#endif 53 54 virtual ~Proxy(); 55 56 virtual void FinishAllRendering() = 0; 57 58 virtual bool IsStarted() const = 0; 59 60 // Will call LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted 61 // with the result of this function. 62 virtual void SetOutputSurface(scoped_ptr<OutputSurface> output_surface) = 0; 63 64 // Indicates that the compositing surface associated with our context is 65 // ready to use. 66 virtual void SetLayerTreeHostClientReady() = 0; 67 68 virtual void SetVisible(bool visible) = 0; 69 70 virtual const RendererCapabilities& GetRendererCapabilities() const = 0; 71 72 virtual void SetNeedsAnimate() = 0; 73 virtual void SetNeedsUpdateLayers() = 0; 74 virtual void SetNeedsCommit() = 0; 75 virtual void SetNeedsRedraw(const gfx::Rect& damage_rect) = 0; 76 virtual void SetNextCommitWaitsForActivation() = 0; 77 78 virtual void NotifyInputThrottledUntilCommit() = 0; 79 80 // Defers commits until it is reset. It is only supported when in threaded 81 // mode. It's an error to make a sync call like CompositeAndReadback while 82 // commits are deferred. 83 virtual void SetDeferCommits(bool defer_commits) = 0; 84 85 virtual void MainThreadHasStoppedFlinging() = 0; 86 87 virtual bool CommitRequested() const = 0; 88 virtual bool BeginMainFrameRequested() const = 0; 89 90 // Must be called before using the proxy. 91 virtual void Start() = 0; 92 virtual void Stop() = 0; // Must be called before deleting the proxy. 93 94 // Forces 3D commands on all contexts to wait for all previous SwapBuffers 95 // to finish before executing in the GPU process. 96 virtual void ForceSerializeOnSwapBuffers() = 0; 97 98 // Maximum number of sub-region texture updates supported for each commit. 99 virtual size_t MaxPartialTextureUpdates() const = 0; 100 101 virtual bool SupportsImplScrolling() const = 0; 102 103 virtual void AsValueInto(base::debug::TracedValue* value) const = 0; 104 105 virtual void SetDebugState(const LayerTreeDebugState& debug_state) = 0; 106 107 // Testing hooks 108 virtual bool MainFrameWillHappenForTesting() = 0; 109 110 BlockingTaskRunner* blocking_main_thread_task_runner() const { 111 return blocking_main_thread_task_runner_.get(); 112 } 113 114 protected: 115 Proxy(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, 116 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner); 117 friend class DebugScopedSetImplThread; 118 friend class DebugScopedSetMainThread; 119 friend class DebugScopedSetMainThreadBlocked; 120 121 private: 122 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_; 123 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_; 124 scoped_ptr<BlockingTaskRunner> blocking_main_thread_task_runner_; 125 126#if DCHECK_IS_ON 127 const base::PlatformThreadId main_thread_id_; 128 bool impl_thread_is_overridden_; 129 bool is_main_thread_blocked_; 130#endif 131 132 DISALLOW_COPY_AND_ASSIGN(Proxy); 133}; 134 135#if DCHECK_IS_ON 136class DebugScopedSetMainThreadBlocked { 137 public: 138 explicit DebugScopedSetMainThreadBlocked(Proxy* proxy) : proxy_(proxy) { 139 DCHECK(!proxy_->IsMainThreadBlocked()); 140 proxy_->SetMainThreadBlocked(true); 141 } 142 ~DebugScopedSetMainThreadBlocked() { 143 DCHECK(proxy_->IsMainThreadBlocked()); 144 proxy_->SetMainThreadBlocked(false); 145 } 146 private: 147 Proxy* proxy_; 148 DISALLOW_COPY_AND_ASSIGN(DebugScopedSetMainThreadBlocked); 149}; 150#else 151class DebugScopedSetMainThreadBlocked { 152 public: 153 explicit DebugScopedSetMainThreadBlocked(Proxy* proxy) {} 154 ~DebugScopedSetMainThreadBlocked() {} 155 private: 156 DISALLOW_COPY_AND_ASSIGN(DebugScopedSetMainThreadBlocked); 157}; 158#endif 159 160} // namespace cc 161 162#endif // CC_TREES_PROXY_H_ 163