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
|
// 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 "base/message_loop/message_loop_proxy.h"
#include "build/build_config.h"
#include "content/common/gpu/devtools_gpu_instrumentation.h"
#include "content/common/gpu/gpu_memory_manager.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.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 {
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;
class SyncPointManager;
// 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 GpuChannelManager : public IPC::Listener,
public IPC::Sender {
public:
GpuChannelManager(MessageRouter* router,
GpuWatchdog* watchdog,
base::MessageLoopProxy* io_message_loop,
base::WaitableEvent* shutdown_event,
IPC::SyncChannel* channel);
virtual ~GpuChannelManager();
// Remove the channel for a particular renderer.
void RemoveChannel(int client_id);
// Listener overrides.
virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
// Sender overrides.
virtual 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_; }
GpuEventsDispatcher* gpu_devtools_events_dispatcher() {
return &gpu_devtools_events_dispatcher_;
}
GpuChannel* LookupChannel(int32 client_id);
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, 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(const gfx::GpuMemoryBufferHandle& handle);
void DestroyGpuMemoryBufferOnIO(const gfx::GpuMemoryBufferHandle& handle);
void OnDestroyGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
int32 sync_point);
void OnLoseAllContexts();
scoped_refptr<base::MessageLoopProxy> io_message_loop_;
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_;
GpuEventsDispatcher gpu_devtools_events_dispatcher_;
GpuWatchdog* watchdog_;
scoped_refptr<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_;
// 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_
|
