content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h

   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 CONTENT_COMMON_GPU_CLIENT_WEBGRAPHICSCONTEXT3D_COMMAND_BUFFER_IMPL_H_
   6 #define CONTENT_COMMON_GPU_CLIENT_WEBGRAPHICSCONTEXT3D_COMMAND_BUFFER_IMPL_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/synchronization/lock.h"
  15 #include "content/common/content_export.h"
  16 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
  17 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
  18 #include "third_party/WebKit/public/platform/WebString.h"
  19 #include "ui/gfx/native_widget_types.h"
  20 #include "ui/gl/gpu_preference.h"
  21 #include "url/gurl.h"
  22 #include "webkit/common/gpu/webgraphicscontext3d_impl.h"
  23
  24 namespace gpu {
  25
  26 class ContextSupport;
  27 class TransferBuffer;
  28
  29 namespace gles2 {
  30 class GLES2CmdHelper;
  31 class GLES2Implementation;
  32 class GLES2Interface;
  33 }
  34 }
  35
  36 namespace content {
  37 class GpuChannelHost;
  38
  39 const size_t kDefaultCommandBufferSize = 1024 * 1024;
  40 const size_t kDefaultStartTransferBufferSize = 1 * 1024 * 1024;
  41 const size_t kDefaultMinTransferBufferSize = 1 * 256 * 1024;
  42 const size_t kDefaultMaxTransferBufferSize = 16 * 1024 * 1024;
  43
  44 class WebGraphicsContext3DCommandBufferImpl
  45     : public webkit::gpu::WebGraphicsContext3DImpl {
  46  public:
  47   enum MappedMemoryReclaimLimit {
  48     kNoLimit = 0,
  49   };
  50
  51   struct CONTENT_EXPORT SharedMemoryLimits {
  52     SharedMemoryLimits();
  53
  54     size_t command_buffer_size;
  55     size_t start_transfer_buffer_size;
  56     size_t min_transfer_buffer_size;
  57     size_t max_transfer_buffer_size;
  58     size_t mapped_memory_reclaim_limit;
  59   };
  60
  61   class ShareGroup : public base::RefCountedThreadSafe<ShareGroup> {
  62    public:
  63     ShareGroup();
  64
  65     WebGraphicsContext3DCommandBufferImpl* GetAnyContextLocked() {
  66       // In order to ensure that the context returned is not removed while
  67       // in use, the share group's lock should be aquired before calling this
  68       // function.
  69       lock_.AssertAcquired();
  70       if (contexts_.empty())
  71         return NULL;
  72       return contexts_.front();
  73     }
  74
  75     void AddContextLocked(WebGraphicsContext3DCommandBufferImpl* context) {
  76       lock_.AssertAcquired();
  77       contexts_.push_back(context);
  78     }
  79
  80     void RemoveContext(WebGraphicsContext3DCommandBufferImpl* context) {
  81       base::AutoLock auto_lock(lock_);
  82       contexts_.erase(std::remove(contexts_.begin(), contexts_.end(), context),
  83           contexts_.end());
  84     }
  85
  86     void RemoveAllContexts() {
  87       base::AutoLock auto_lock(lock_);
  88       contexts_.clear();
  89     }
  90
  91     base::Lock& lock() {
  92       return lock_;
  93     }
  94
  95    private:
  96     friend class base::RefCountedThreadSafe<ShareGroup>;
  97     virtual ~ShareGroup();
  98
  99     std::vector<WebGraphicsContext3DCommandBufferImpl*> contexts_;
 100     base::Lock lock_;
 101
 102     DISALLOW_COPY_AND_ASSIGN(ShareGroup);
 103   };
 104
 105   WebGraphicsContext3DCommandBufferImpl(
 106       int surface_id,
 107       const GURL& active_url,
 108       GpuChannelHost* host,
 109       const Attributes& attributes,
 110       bool lose_context_when_out_of_memory,
 111       const SharedMemoryLimits& limits,
 112       WebGraphicsContext3DCommandBufferImpl* share_context);
 113
 114   virtual ~WebGraphicsContext3DCommandBufferImpl();
 115
 116   CommandBufferProxyImpl* GetCommandBufferProxy() {
 117     return command_buffer_.get();
 118   }
 119
 120   CONTENT_EXPORT gpu::ContextSupport* GetContextSupport();
 121
 122   gpu::gles2::GLES2Implementation* GetImplementation() {
 123     return real_gl_.get();
 124   }
 125
 126   // Return true if GPU process reported context lost or there was a
 127   // problem communicating with the GPU process.
 128   bool IsCommandBufferContextLost();
 129
 130   // Create & initialize a WebGraphicsContext3DCommandBufferImpl.  Return NULL
 131   // on any failure.
 132   static CONTENT_EXPORT WebGraphicsContext3DCommandBufferImpl*
 133       CreateOffscreenContext(
 134           GpuChannelHost* host,
 135           const WebGraphicsContext3D::Attributes& attributes,
 136           bool lose_context_when_out_of_memory,
 137           const GURL& active_url,
 138           const SharedMemoryLimits& limits,
 139           WebGraphicsContext3DCommandBufferImpl* share_context);
 140
 141   size_t GetMappedMemoryLimit() {
 142     return mem_limits_.mapped_memory_reclaim_limit;
 143   }
 144
 145   //----------------------------------------------------------------------
 146   // WebGraphicsContext3D methods
 147
 148   // Must be called after initialize() and before any of the following methods.
 149   // Permanently binds to the first calling thread. Returns false if the
 150   // graphics context fails to create. Do not call from more than one thread.
 151   virtual bool makeContextCurrent();
 152
 153   virtual bool isContextLost();
 154
 155   virtual WGC3Denum getGraphicsResetStatusARB();
 156
 157  private:
 158   // These are the same error codes as used by EGL.
 159   enum Error {
 160     SUCCESS               = 0x3000,
 161     BAD_ATTRIBUTE         = 0x3004,
 162     CONTEXT_LOST          = 0x300E
 163   };
 164
 165   // Initialize the underlying GL context. May be called multiple times; second
 166   // and subsequent calls are ignored. Must be called from the thread that is
 167   // going to use this object to issue GL commands (which might not be the main
 168   // thread).
 169   bool MaybeInitializeGL();
 170
 171   bool InitializeCommandBuffer(bool onscreen,
 172       WebGraphicsContext3DCommandBufferImpl* share_context);
 173
 174   void Destroy();
 175
 176   // Create a CommandBufferProxy that renders directly to a view. The view and
 177   // the associated window must not be destroyed until the returned
 178   // CommandBufferProxy has been destroyed, otherwise the GPU process might
 179   // attempt to render to an invalid window handle.
 180   //
 181   // NOTE: on Mac OS X, this entry point is only used to set up the
 182   // accelerated compositor's output. On this platform, we actually pass
 183   // a gfx::PluginWindowHandle in place of the gfx::NativeViewId,
 184   // because the facility to allocate a fake PluginWindowHandle is
 185   // already in place. We could add more entry points and messages to
 186   // allocate both fake PluginWindowHandles and NativeViewIds and map
 187   // from fake NativeViewIds to PluginWindowHandles, but this seems like
 188   // unnecessary complexity at the moment.
 189   bool CreateContext(bool onscreen);
 190
 191   virtual void OnGpuChannelLost();
 192
 193   bool lose_context_when_out_of_memory_;
 194   blink::WebGraphicsContext3D::Attributes attributes_;
 195
 196   bool visible_;
 197
 198   // State needed by MaybeInitializeGL.
 199   scoped_refptr<GpuChannelHost> host_;
 200   int32 surface_id_;
 201   GURL active_url_;
 202
 203   gfx::GpuPreference gpu_preference_;
 204
 205   base::WeakPtrFactory<WebGraphicsContext3DCommandBufferImpl> weak_ptr_factory_;
 206
 207   scoped_ptr<CommandBufferProxyImpl> command_buffer_;
 208   scoped_ptr<gpu::gles2::GLES2CmdHelper> gles2_helper_;
 209   scoped_ptr<gpu::TransferBuffer> transfer_buffer_;
 210   scoped_ptr<gpu::gles2::GLES2Implementation> real_gl_;
 211   scoped_ptr<gpu::gles2::GLES2Interface> trace_gl_;
 212   Error last_error_;
 213   SharedMemoryLimits mem_limits_;
 214   scoped_refptr<ShareGroup> share_group_;
 215 };
 216
 217 }  // namespace content
 218
 219 #endif  // CONTENT_COMMON_GPU_CLIENT_WEBGRAPHICSCONTEXT3D_COMMAND_BUFFER_IMPL_H_