Home | History | Annotate | Download | only in client 
      1 // Copyright 2013 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_GPU_MEMORY_BUFFER_IMPL_H_
      6 #define CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_IMPL_H_
      7 
      8 #include "base/callback.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "ui/gfx/gpu_memory_buffer.h"
     11 #include "ui/gfx/size.h"
     12 
     13 namespace content {
     14 
     15 // Provides common implementation of a GPU memory buffer.
     16 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
     17  public:
     18   typedef base::Callback<void(scoped_ptr<GpuMemoryBufferImpl> buffer)>
     19       CreationCallback;
     20   typedef base::Callback<void(const gfx::GpuMemoryBufferHandle& handle)>
     21       AllocationCallback;
     22   typedef base::Closure DestructionCallback;
     23 
     24   virtual ~GpuMemoryBufferImpl();
     25 
     26   // Creates a GPU memory buffer instance with |size| and |internalformat| for
     27   // |usage| by the current process and |client_id|.
     28   static void Create(const gfx::Size& size,
     29                      unsigned internalformat,
     30                      unsigned usage,
     31                      int client_id,
     32                      const CreationCallback& callback);
     33 
     34   // Allocates a GPU memory buffer with |size| and |internalformat| for |usage|
     35   // by |child_process| and |child_client_id|. The |handle| returned can be
     36   // used by the |child_process| to create an instance of this class.
     37   static void AllocateForChildProcess(const gfx::Size& size,
     38                                       unsigned internalformat,
     39                                       unsigned usage,
     40                                       base::ProcessHandle child_process,
     41                                       int child_client_id,
     42                                       const AllocationCallback& callback);
     43 
     44   // Notify that GPU memory buffer has been deleted by |child_process|.
     45   static void DeletedByChildProcess(gfx::GpuMemoryBufferType type,
     46                                     const gfx::GpuMemoryBufferId& id,
     47                                     base::ProcessHandle child_process);
     48 
     49   // Creates an instance from the given |handle|. |size| and |internalformat|
     50   // should match what was used to allocate the |handle|. |callback| is
     51   // called when instance is deleted, which is not necessarily on the same
     52   // thread as this function was called on and instance was created on.
     53   static scoped_ptr<GpuMemoryBufferImpl> CreateFromHandle(
     54       const gfx::GpuMemoryBufferHandle& handle,
     55       const gfx::Size& size,
     56       unsigned internalformat,
     57       const DestructionCallback& callback);
     58 
     59   // Returns true if |internalformat| is a format recognized by this base class.
     60   static bool IsFormatValid(unsigned internalformat);
     61 
     62   // Returns true if |usage| is recognized by this base class.
     63   static bool IsUsageValid(unsigned usage);
     64 
     65   // Returns the number of bytes per pixel that must be used by an
     66   // implementation when using |internalformat|.
     67   static size_t BytesPerPixel(unsigned internalformat);
     68 
     69   // Overridden from gfx::GpuMemoryBuffer:
     70   virtual bool IsMapped() const OVERRIDE;
     71 
     72  protected:
     73   GpuMemoryBufferImpl(const gfx::Size& size,
     74                       unsigned internalformat,
     75                       const DestructionCallback& callback);
     76 
     77   const gfx::Size size_;
     78   const unsigned internalformat_;
     79   const DestructionCallback callback_;
     80   bool mapped_;
     81 
     82   DISALLOW_COPY_AND_ASSIGN(GpuMemoryBufferImpl);
     83 };
     84 
     85 }  // namespace content
     86 
     87 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_MEMORY_BUFFER_IMPL_H_
     88