src/gpu/command_buffer/service/async_pixel_transfer_delegate.h

   1 // Copyright (c) 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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_H_
   6 #define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/synchronization/lock.h"
  13 #include "base/time/time.h"
  14 #include "gpu/gpu_export.h"
  15 #include "ui/gl/gl_bindings.h"
  16
  17 namespace base {
  18 class SharedMemory;
  19 }
  20
  21 namespace gpu {
  22
  23 class ScopedSafeSharedMemory;
  24
  25 struct AsyncTexImage2DParams {
  26   GLenum target;
  27   GLint level;
  28   GLenum internal_format;
  29   GLsizei width;
  30   GLsizei height;
  31   GLint border;
  32   GLenum format;
  33   GLenum type;
  34 };
  35
  36 struct AsyncTexSubImage2DParams {
  37   GLenum target;
  38   GLint level;
  39   GLint xoffset;
  40   GLint yoffset;
  41   GLsizei width;
  42   GLsizei height;
  43   GLenum format;
  44   GLenum type;
  45 };
  46
  47 struct AsyncMemoryParams {
  48   base::SharedMemory* shared_memory;
  49   uint32 shm_size;
  50   uint32 shm_data_offset;
  51   uint32 shm_data_size;
  52 };
  53
  54 class AsyncPixelTransferUploadStats
  55     : public base::RefCountedThreadSafe<AsyncPixelTransferUploadStats> {
  56  public:
  57   AsyncPixelTransferUploadStats();
  58
  59   void AddUpload(base::TimeDelta transfer_time);
  60   int GetStats(base::TimeDelta* total_texture_upload_time);
  61
  62  private:
  63   friend class base::RefCountedThreadSafe<AsyncPixelTransferUploadStats>;
  64
  65   ~AsyncPixelTransferUploadStats();
  66
  67   int texture_upload_count_;
  68   base::TimeDelta total_texture_upload_time_;
  69   base::Lock lock_;
  70
  71   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferUploadStats);
  72 };
  73
  74 class GPU_EXPORT AsyncPixelTransferDelegate {
  75  public:
  76   virtual ~AsyncPixelTransferDelegate();
  77
  78   // The callback occurs on the caller thread, once the texture is
  79   // safe/ready to be used.
  80   virtual void AsyncTexImage2D(
  81       const AsyncTexImage2DParams& tex_params,
  82       const AsyncMemoryParams& mem_params,
  83       const base::Closure& bind_callback) = 0;
  84
  85   virtual void AsyncTexSubImage2D(
  86       const AsyncTexSubImage2DParams& tex_params,
  87       const AsyncMemoryParams& mem_params) = 0;
  88
  89   // Returns true if there is a transfer in progress.
  90   virtual bool TransferIsInProgress() = 0;
  91
  92   // Block until the specified transfer completes.
  93   virtual void WaitForTransferCompletion() = 0;
  94
  95   // Gets the address of the data from shared memory.
  96   static void* GetAddress(const AsyncMemoryParams& mem_params);
  97
  98   // Sometimes the |safe_shared_memory| is duplicate to prevent use after free.
  99   static void* GetAddress(ScopedSafeSharedMemory* safe_shared_memory,
 100                           const AsyncMemoryParams& mem_params);
 101
 102  protected:
 103   AsyncPixelTransferDelegate();
 104
 105  private:
 106   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegate);
 107 };
 108
 109 }  // namespace gpu
 110
 111 #endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_H_
 112