1// Copyright (c) 2012 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 UI_GL_GL_CONTEXT_H_
6#define UI_GL_GL_CONTEXT_H_
7
8#include <string>
9#include <vector>
10
11#include "base/basictypes.h"
12#include "base/memory/ref_counted.h"
13#include "base/memory/scoped_ptr.h"
14#include "base/synchronization/cancellation_flag.h"
15#include "ui/gl/gl_share_group.h"
16#include "ui/gl/gl_state_restorer.h"
17#include "ui/gl/gpu_preference.h"
18
19namespace gfx {
20
21class GLSurface;
22class VirtualGLApi;
23struct GLVersionInfo;
24
25// Encapsulates an OpenGL context, hiding platform specific management.
26class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
27 public:
28  explicit GLContext(GLShareGroup* share_group);
29
30  // Initializes the GL context to be compatible with the given surface. The GL
31  // context can be made with other surface's of the same type. The compatible
32  // surface is only needed for certain platforms like WGL, OSMesa and GLX. It
33  // should be specific for all platforms though.
34  virtual bool Initialize(
35      GLSurface* compatible_surface, GpuPreference gpu_preference) = 0;
36
37  class FlushEvent : public base::RefCountedThreadSafe<FlushEvent> {
38    public:
39      bool IsSignaled();
40
41    private:
42      friend class base::RefCountedThreadSafe<FlushEvent>;
43      friend class GLContext;
44      FlushEvent();
45      virtual ~FlushEvent();
46      void Signal();
47
48      base::CancellationFlag flag_;
49  };
50
51  // Needs to be called with this context current. It will return a FlushEvent
52  // that is initially unsignaled, but will transition to signaled after the
53  // next glFlush() or glFinish() occurs in this context.
54  scoped_refptr<FlushEvent> SignalFlush();
55
56  // Destroys the GL context.
57  virtual void Destroy() = 0;
58
59  // Makes the GL context and a surface current on the current thread.
60  virtual bool MakeCurrent(GLSurface* surface) = 0;
61
62  // Releases this GL context and surface as current on the current thread.
63  virtual void ReleaseCurrent(GLSurface* surface) = 0;
64
65  // Returns true if this context and surface is current. Pass a null surface
66  // if the current surface is not important.
67  virtual bool IsCurrent(GLSurface* surface) = 0;
68
69  // Get the underlying platform specific GL context "handle".
70  virtual void* GetHandle() = 0;
71
72  // Gets the GLStateRestorer for the context.
73  GLStateRestorer* GetGLStateRestorer();
74
75  // Sets the GLStateRestorer for the context (takes ownership).
76  void SetGLStateRestorer(GLStateRestorer* state_restorer);
77
78  // Set swap interval. This context must be current.
79  virtual void SetSwapInterval(int interval) = 0;
80
81  // Returns space separated list of extensions. The context must be current.
82  virtual std::string GetExtensions();
83
84  // Returns in bytes the total amount of GPU memory for the GPU which this
85  // context is currently rendering on. Returns false if no extension exists
86  // to get the exact amount of GPU memory.
87  virtual bool GetTotalGpuMemory(size_t* bytes);
88
89  // Indicate that it is safe to force this context to switch GPUs, since
90  // transitioning can cause corruption and hangs (OS X only).
91  virtual void SetSafeToForceGpuSwitch();
92
93  // Indicate that the real context switches should unbind the FBO first
94  // (For an Android work-around only).
95  virtual void SetUnbindFboOnMakeCurrent();
96
97  // Returns whether the current context supports the named extension. The
98  // context must be current.
99  bool HasExtension(const char* name);
100
101  // Returns version info of the underlying GL context. The context must be
102  // current.
103  const GLVersionInfo* GetVersionInfo();
104
105  GLShareGroup* share_group();
106
107  // Create a GL context that is compatible with the given surface.
108  // |share_group|, if non-NULL, is a group of contexts which the
109  // internally created OpenGL context shares textures and other resources.
110  static scoped_refptr<GLContext> CreateGLContext(
111      GLShareGroup* share_group,
112      GLSurface* compatible_surface,
113      GpuPreference gpu_preference);
114
115  static bool LosesAllContextsOnContextLost();
116
117  // Returns the last GLContext made current, virtual or real.
118  static GLContext* GetCurrent();
119
120  virtual bool WasAllocatedUsingRobustnessExtension();
121
122  // Use this context for virtualization.
123  void SetupForVirtualization();
124
125  // Make this context current when used for context virtualization.
126  bool MakeVirtuallyCurrent(GLContext* virtual_context, GLSurface* surface);
127
128  // Notify this context that |virtual_context|, that was using us, is
129  // being released or destroyed.
130  void OnReleaseVirtuallyCurrent(GLContext* virtual_context);
131
132  // Returns the GL version string. The context must be current.
133  virtual std::string GetGLVersion();
134
135  // Returns the GL renderer string. The context must be current.
136  virtual std::string GetGLRenderer();
137
138  // Called when glFlush()/glFinish() is called with this context current.
139  void OnFlush();
140
141 protected:
142  virtual ~GLContext();
143
144  // Will release the current context when going out of scope, unless canceled.
145  class ScopedReleaseCurrent {
146   public:
147    ScopedReleaseCurrent();
148    ~ScopedReleaseCurrent();
149
150    void Cancel();
151
152   private:
153    bool canceled_;
154  };
155
156  // Sets the GL api to the real hardware API (vs the VirtualAPI)
157  static void SetRealGLApi();
158  virtual void SetCurrent(GLSurface* surface);
159
160  // Initialize function pointers to functions where the bound version depends
161  // on GL version or supported extensions. Should be called immediately after
162  // this context is made current.
163  bool InitializeDynamicBindings();
164
165  // Returns the last real (non-virtual) GLContext made current.
166  static GLContext* GetRealCurrent();
167
168 private:
169  friend class base::RefCounted<GLContext>;
170
171  // For GetRealCurrent.
172  friend class VirtualGLApi;
173
174  scoped_refptr<GLShareGroup> share_group_;
175  scoped_ptr<VirtualGLApi> virtual_gl_api_;
176  scoped_ptr<GLStateRestorer> state_restorer_;
177  scoped_ptr<GLVersionInfo> version_info_;
178
179  std::vector<scoped_refptr<FlushEvent> > flush_events_;
180
181  DISALLOW_COPY_AND_ASSIGN(GLContext);
182};
183
184class GL_EXPORT GLContextReal : public GLContext {
185 public:
186  explicit GLContextReal(GLShareGroup* share_group);
187
188 protected:
189  virtual ~GLContextReal();
190
191  virtual void SetCurrent(GLSurface* surface) OVERRIDE;
192
193 private:
194  DISALLOW_COPY_AND_ASSIGN(GLContextReal);
195};
196
197}  // namespace gfx
198
199#endif  // UI_GL_GL_CONTEXT_H_
200