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 19 namespace base { 20 namespace debug { 21 class TracedValue; 22 } 23 class SingleThreadTaskRunner; 24 } 25 26 namespace gfx { 27 class Rect; 28 class Vector2d; 29 } 30 31 namespace cc { 32 class BlockingTaskRunner; 33 class LayerTreeDebugState; 34 class OutputSurface; 35 struct RendererCapabilities; 36 37 // Abstract class responsible for proxying commands from the main-thread side of 38 // the compositor over to the compositor implementation. 39 class 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 blocking_main_thread_task_runner()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 136 class DebugScopedSetMainThreadBlocked { 137 public: DebugScopedSetMainThreadBlocked(Proxy * proxy)138 explicit DebugScopedSetMainThreadBlocked(Proxy* proxy) : proxy_(proxy) { 139 DCHECK(!proxy_->IsMainThreadBlocked()); 140 proxy_->SetMainThreadBlocked(true); 141 } ~DebugScopedSetMainThreadBlocked()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 151 class DebugScopedSetMainThreadBlocked { 152 public: DebugScopedSetMainThreadBlocked(Proxy * proxy)153 explicit DebugScopedSetMainThreadBlocked(Proxy* proxy) {} ~DebugScopedSetMainThreadBlocked()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