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