cc/proxy.h

   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_PROXY_H_
   6 #define CC_PROXY_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/logging.h"
  10 #include "base/time.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include <public/WebCompositorOutputSurface.h>
  13 #include "cc/cc_export.h"
  14
  15 namespace gfx {
  16 class Rect;
  17 class Vector2d;
  18 }
  19
  20 namespace cc {
  21
  22 class Thread;
  23 struct RenderingStats;
  24 struct RendererCapabilities;
  25
  26 // Abstract class responsible for proxying commands from the main-thread side of
  27 // the compositor over to the compositor implementation.
  28 class CC_EXPORT Proxy {
  29 public:
  30     Thread* mainThread() const;
  31     bool hasImplThread() const;
  32     Thread* implThread() const;
  33
  34     // Returns 0 if the current thread is neither the main thread nor the impl thread.
  35     Thread* currentThread() const;
  36
  37     // Debug hooks
  38     bool isMainThread() const;
  39     bool isImplThread() const;
  40     bool isMainThreadBlocked() const;
  41 #ifndef NDEBUG
  42     void setMainThreadBlocked(bool);
  43     void setCurrentThreadIsImplThread(bool);
  44 #endif
  45
  46     virtual ~Proxy();
  47
  48     virtual bool compositeAndReadback(void *pixels, const gfx::Rect&) = 0;
  49
  50     virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration) = 0;
  51
  52     virtual void finishAllRendering() = 0;
  53
  54     virtual bool isStarted() const = 0;
  55
  56     // Attempts to initialize a context to use for rendering. Returns false if the context could not be created.
  57     // The context will not be used and no frames may be produced until initializeRenderer() is called.
  58     virtual bool initializeContext() = 0;
  59
  60     // Indicates that the compositing surface associated with our context is ready to use.
  61     virtual void setSurfaceReady() = 0;
  62
  63     virtual void setVisible(bool) = 0;
  64
  65     // Attempts to initialize the layer renderer. Returns false if the context isn't usable for compositing.
  66     virtual bool initializeRenderer() = 0;
  67
  68     // Attempts to recreate the context and layer renderer after a context lost. Returns false if the renderer couldn't be
  69     // reinitialized.
  70     virtual bool recreateContext() = 0;
  71
  72     virtual void renderingStats(RenderingStats*) = 0;
  73
  74     virtual const RendererCapabilities& rendererCapabilities() const = 0;
  75
  76     virtual void setNeedsAnimate() = 0;
  77     virtual void setNeedsCommit() = 0;
  78     virtual void setNeedsRedraw() = 0;
  79
  80     // Defers commits until it is reset. It is only supported when in threaded mode. It's an error to make a sync call
  81     // like compositeAndReadback while commits are deferred.
  82     virtual void setDeferCommits(bool) = 0;
  83
  84     virtual void didAddAnimation() = 0;
  85
  86     virtual bool commitRequested() const = 0;
  87
  88     virtual void start() = 0; // Must be called before using the proxy.
  89     virtual void stop() = 0; // Must be called before deleting the proxy.
  90
  91     // Forces 3D commands on all contexts to wait for all previous SwapBuffers to finish before executing in the GPU
  92     // process.
  93     virtual void forceSerializeOnSwapBuffers() = 0;
  94
  95     // Maximum number of sub-region texture updates supported for each commit.
  96     virtual size_t maxPartialTextureUpdates() const = 0;
  97
  98     virtual void acquireLayerTextures() = 0;
  99
 100     // Testing hooks
 101     virtual void loseContext() = 0;
 102
 103 protected:
 104     explicit Proxy(scoped_ptr<Thread> implThread);
 105     friend class DebugScopedSetImplThread;
 106     friend class DebugScopedSetMainThread;
 107     friend class DebugScopedSetMainThreadBlocked;
 108
 109 private:
 110     DISALLOW_COPY_AND_ASSIGN(Proxy);
 111
 112     scoped_ptr<Thread> m_mainThread;
 113     scoped_ptr<Thread> m_implThread;
 114 #ifndef NDEBUG
 115     bool m_implThreadIsOverridden;
 116     bool m_isMainThreadBlocked;
 117 #endif
 118 };
 119
 120 #ifndef NDEBUG
 121 class DebugScopedSetMainThreadBlocked {
 122 public:
 123     explicit DebugScopedSetMainThreadBlocked(Proxy* proxy)
 124         : m_proxy(proxy)
 125     {
 126         DCHECK(!m_proxy->isMainThreadBlocked());
 127         m_proxy->setMainThreadBlocked(true);
 128     }
 129     ~DebugScopedSetMainThreadBlocked()
 130     {
 131         DCHECK(m_proxy->isMainThreadBlocked());
 132         m_proxy->setMainThreadBlocked(false);
 133     }
 134 private:
 135     Proxy* m_proxy;
 136 };
 137 #else
 138 class DebugScopedSetMainThreadBlocked {
 139 public:
 140     explicit DebugScopedSetMainThreadBlocked(Proxy*) { }
 141     ~DebugScopedSetMainThreadBlocked() { }
 142 };
 143 #endif
 144
 145 }
 146
 147 #endif  // CC_PROXY_H_