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 113