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