blob: d0ea5da153c4cf08cdd292d278702c70732949f2 (
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
113
114
115
116
117
118
119
|
// Copyright 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_MANAGER_H_
#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_H_
#include <set>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/containers/hash_tables.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/ref_counted.h"
#include "gpu/command_buffer/service/texture_manager.h"
#include "gpu/gpu_export.h"
#if defined(COMPILER_GCC)
namespace BASE_HASH_NAMESPACE {
template <>
struct hash<gpu::gles2::TextureRef*> {
size_t operator()(gpu::gles2::TextureRef* ptr) const {
return hash<size_t>()(reinterpret_cast<size_t>(ptr));
}
};
} // namespace BASE_HASH_NAMESPACE
#endif // COMPILER
namespace gfx {
class GLContext;
}
namespace gpu {
class AsyncPixelTransferDelegate;
struct AsyncMemoryParams;
struct AsyncTexImage2DParams;
class AsyncPixelTransferCompletionObserver
: public base::RefCountedThreadSafe<AsyncPixelTransferCompletionObserver> {
public:
AsyncPixelTransferCompletionObserver();
virtual void DidComplete(const AsyncMemoryParams& mem_params) = 0;
protected:
virtual ~AsyncPixelTransferCompletionObserver();
private:
friend class base::RefCountedThreadSafe<AsyncPixelTransferCompletionObserver>;
DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferCompletionObserver);
};
class GPU_EXPORT AsyncPixelTransferManager
: public gles2::TextureManager::DestructionObserver {
public:
static AsyncPixelTransferManager* Create(gfx::GLContext* context);
virtual ~AsyncPixelTransferManager();
void Initialize(gles2::TextureManager* texture_manager);
virtual void BindCompletedAsyncTransfers() = 0;
// There's no guarantee that callback will run on the caller thread.
virtual void AsyncNotifyCompletion(
const AsyncMemoryParams& mem_params,
AsyncPixelTransferCompletionObserver* observer) = 0;
virtual uint32 GetTextureUploadCount() = 0;
virtual base::TimeDelta GetTotalTextureUploadTime() = 0;
// ProcessMorePendingTransfers() will be called at a good time
// to process a small amount of pending transfer work while
// NeedsProcessMorePendingTransfers() returns true. Implementations
// that can't dispatch work to separate threads should use
// this to avoid blocking the caller thread inappropriately.
virtual void ProcessMorePendingTransfers() = 0;
virtual bool NeedsProcessMorePendingTransfers() = 0;
AsyncPixelTransferDelegate* CreatePixelTransferDelegate(
gles2::TextureRef* ref,
const AsyncTexImage2DParams& define_params);
AsyncPixelTransferDelegate* GetPixelTransferDelegate(
gles2::TextureRef* ref);
void ClearPixelTransferDelegateForTest(gles2::TextureRef* ref);
bool AsyncTransferIsInProgress(gles2::TextureRef* ref);
// gles2::TextureRef::DestructionObserver implementation:
virtual void OnTextureManagerDestroying(gles2::TextureManager* manager)
OVERRIDE;
virtual void OnTextureRefDestroying(gles2::TextureRef* texture) OVERRIDE;
protected:
AsyncPixelTransferManager();
private:
gles2::TextureManager* manager_;
typedef base::hash_map<gles2::TextureRef*,
linked_ptr<AsyncPixelTransferDelegate> >
TextureToDelegateMap;
TextureToDelegateMap delegate_map_;
// A factory method called by CreatePixelTransferDelegate that is overriden
// by each implementation.
virtual AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
gles2::TextureRef* ref,
const AsyncTexImage2DParams& define_params) = 0;
DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManager);
};
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_H_
|
