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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright (c) 2012 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 CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
#define CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
#include <deque>
#include <string>
#include <vector>
#include "base/containers/scoped_ptr_hash_map.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/common/content_param_traits.h"
#include "content/common/gpu/gpu_memory_manager.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
#include "ui/gfx/gpu_memory_buffer.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/gl/gl_surface.h"
namespace base {
class WaitableEvent;
}
namespace gfx {
class GLShareGroup;
struct GpuMemoryBufferHandle;
}
namespace gpu {
class SyncPointManager;
union ValueState;
namespace gles2 {
class MailboxManager;
class ProgramCache;
class ShaderTranslatorCache;
}
}
namespace IPC {
struct ChannelHandle;
class SyncChannel;
class MessageFilter;
}
struct GPUCreateCommandBufferConfig;
namespace content {
class GpuChannel;
class GpuMemoryBufferFactory;
class GpuWatchdog;
class MessageRouter;
// A GpuChannelManager is a thread responsible for issuing rendering commands
// managing the lifetimes of GPU channels and forwarding IPC requests from the
// browser process to them based on the corresponding renderer ID.
class CONTENT_EXPORT GpuChannelManager : public IPC::Listener,
public IPC::Sender {
public:
GpuChannelManager(MessageRouter* router,
GpuWatchdog* watchdog,
base::SingleThreadTaskRunner* io_task_runner,
base::WaitableEvent* shutdown_event,
IPC::SyncChannel* channel);
~GpuChannelManager() override;
// Remove the channel for a particular renderer.
void RemoveChannel(int client_id);
// Listener overrides.
bool OnMessageReceived(const IPC::Message& msg) override;
// Sender overrides.
bool Send(IPC::Message* msg) override;
bool HandleMessagesScheduled();
uint64 MessagesProcessed();
void LoseAllContexts();
int GenerateRouteID();
void AddRoute(int32 routing_id, IPC::Listener* listener);
void RemoveRoute(int32 routing_id);
gpu::gles2::ProgramCache* program_cache();
gpu::gles2::ShaderTranslatorCache* shader_translator_cache();
GpuMemoryManager* gpu_memory_manager() { return &gpu_memory_manager_; }
GpuChannel* LookupChannel(int32 client_id);
gpu::SyncPointManager* sync_point_manager() {
return sync_point_manager_.get();
}
gfx::GLSurface* GetDefaultOffscreenSurface();
GpuMemoryBufferFactory* gpu_memory_buffer_factory() {
return gpu_memory_buffer_factory_.get();
}
private:
typedef base::ScopedPtrHashMap<int, scoped_ptr<GpuChannel>> GpuChannelMap;
// Message handlers.
void OnEstablishChannel(int client_id,
bool share_context,
bool allow_future_sync_points);
void OnCloseChannel(const IPC::ChannelHandle& channel_handle);
void OnVisibilityChanged(
int32 render_view_id, int32 client_id, bool visible);
void OnCreateViewCommandBuffer(
const gfx::GLSurfaceHandle& window,
int32 render_view_id,
int32 client_id,
const GPUCreateCommandBufferConfig& init_params,
int32 route_id);
void OnLoadedShader(std::string shader);
void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id, int client_id);
void DestroyGpuMemoryBufferOnIO(gfx::GpuMemoryBufferId id, int client_id);
void OnDestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
int client_id,
int32 sync_point);
void OnRelinquishResources();
void OnResourcesRelinquished();
void OnUpdateValueState(int client_id,
unsigned int target,
const gpu::ValueState& state);
void OnLoseAllContexts();
void CheckRelinquishGpuResources();
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
base::WaitableEvent* shutdown_event_;
// Used to send and receive IPC messages from the browser process.
MessageRouter* const router_;
// These objects manage channels to individual renderer processes there is
// one channel for each renderer process that has connected to this GPU
// process.
GpuChannelMap gpu_channels_;
scoped_refptr<gfx::GLShareGroup> share_group_;
scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
GpuMemoryManager gpu_memory_manager_;
GpuWatchdog* watchdog_;
scoped_refptr<gpu::SyncPointManager> sync_point_manager_;
scoped_ptr<gpu::gles2::ProgramCache> program_cache_;
scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
scoped_refptr<gfx::GLSurface> default_offscreen_surface_;
scoped_ptr<GpuMemoryBufferFactory> gpu_memory_buffer_factory_;
IPC::SyncChannel* channel_;
scoped_refptr<IPC::MessageFilter> filter_;
bool relinquish_resources_pending_;
// Member variables should appear before the WeakPtrFactory, to ensure
// that any WeakPtrs to Controller are invalidated before its members
// variable's destructors are executed, rendering them invalid.
base::WeakPtrFactory<GpuChannelManager> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(GpuChannelManager);
};
} // namespace content
#endif // CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
|
