1 // Copyright (c) 2012 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 CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_ 6 #define CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_ 7 8 #include <deque> 9 #include <string> 10 #include <vector> 11 12 #include "base/memory/scoped_vector.h" 13 #include "base/memory/weak_ptr.h" 14 #include "base/observer_list.h" 15 #include "content/common/content_export.h" 16 #include "content/common/gpu/gpu_memory_manager.h" 17 #include "content/common/gpu/gpu_memory_manager_client.h" 18 #include "gpu/command_buffer/common/constants.h" 19 #include "gpu/command_buffer/common/gpu_memory_allocation.h" 20 #include "gpu/command_buffer/service/command_buffer_service.h" 21 #include "gpu/command_buffer/service/context_group.h" 22 #include "gpu/command_buffer/service/gpu_scheduler.h" 23 #include "ipc/ipc_listener.h" 24 #include "ipc/ipc_sender.h" 25 #include "media/base/video_decoder_config.h" 26 #include "ui/events/latency_info.h" 27 #include "ui/gfx/gpu_memory_buffer.h" 28 #include "ui/gfx/native_widget_types.h" 29 #include "ui/gfx/size.h" 30 #include "ui/gl/gl_surface.h" 31 #include "ui/gl/gpu_preference.h" 32 #include "url/gurl.h" 33 34 namespace gpu { 35 class GpuControlService; 36 struct Mailbox; 37 namespace gles2 { 38 class ImageManager; 39 class MailboxManager; 40 } 41 } 42 43 namespace content { 44 45 class GpuChannel; 46 class GpuVideoDecodeAccelerator; 47 class GpuVideoEncodeAccelerator; 48 class GpuWatchdog; 49 struct WaitForCommandState; 50 51 class GpuCommandBufferStub 52 : public GpuMemoryManagerClient, 53 public IPC::Listener, 54 public IPC::Sender, 55 public base::SupportsWeakPtr<GpuCommandBufferStub> { 56 public: 57 class DestructionObserver { 58 public: 59 // Called in Destroy(), before the context/surface are released. 60 virtual void OnWillDestroyStub() = 0; 61 62 protected: ~DestructionObserver()63 virtual ~DestructionObserver() {} 64 }; 65 66 typedef base::Callback<void(const std::vector<ui::LatencyInfo>&)> 67 LatencyInfoCallback; 68 69 GpuCommandBufferStub( 70 GpuChannel* channel, 71 GpuCommandBufferStub* share_group, 72 const gfx::GLSurfaceHandle& handle, 73 gpu::gles2::MailboxManager* mailbox_manager, 74 gpu::gles2::ImageManager* image_manager, 75 const gfx::Size& size, 76 const gpu::gles2::DisallowedFeatures& disallowed_features, 77 const std::vector<int32>& attribs, 78 gfx::GpuPreference gpu_preference, 79 bool use_virtualized_gl_context, 80 int32 route_id, 81 int32 surface_id, 82 GpuWatchdog* watchdog, 83 bool software, 84 const GURL& active_url); 85 86 virtual ~GpuCommandBufferStub(); 87 88 // IPC::Listener implementation: 89 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; 90 91 // IPC::Sender implementation: 92 virtual bool Send(IPC::Message* msg) OVERRIDE; 93 94 // GpuMemoryManagerClient implementation: 95 virtual gfx::Size GetSurfaceSize() const OVERRIDE; 96 virtual gpu::gles2::MemoryTracker* GetMemoryTracker() const OVERRIDE; 97 virtual void SetMemoryAllocation( 98 const gpu::MemoryAllocation& allocation) OVERRIDE; 99 virtual void SuggestHaveFrontBuffer(bool suggest_have_frontbuffer) OVERRIDE; 100 virtual bool GetTotalGpuMemory(uint64* bytes) OVERRIDE; 101 102 // Whether this command buffer can currently handle IPC messages. 103 bool IsScheduled(); 104 105 // If the command buffer is pre-empted and cannot process commands. IsPreempted()106 bool IsPreempted() const { 107 return scheduler_.get() && scheduler_->IsPreempted(); 108 } 109 110 // Whether there are commands in the buffer that haven't been processed. 111 bool HasUnprocessedCommands(); 112 decoder()113 gpu::gles2::GLES2Decoder* decoder() const { return decoder_.get(); } scheduler()114 gpu::GpuScheduler* scheduler() const { return scheduler_.get(); } channel()115 GpuChannel* channel() const { return channel_; } 116 117 // Identifies the target surface. surface_id()118 int32 surface_id() const { return surface_id_; } 119 120 // Identifies the various GpuCommandBufferStubs in the GPU process belonging 121 // to the same renderer process. route_id()122 int32 route_id() const { return route_id_; } 123 gpu_preference()124 gfx::GpuPreference gpu_preference() { return gpu_preference_; } 125 126 int32 GetRequestedAttribute(int attr) const; 127 128 // Sends a message to the console. 129 void SendConsoleMessage(int32 id, const std::string& message); 130 131 void SendCachedShader(const std::string& key, const std::string& shader); 132 surface()133 gfx::GLSurface* surface() const { return surface_.get(); } 134 135 void AddDestructionObserver(DestructionObserver* observer); 136 void RemoveDestructionObserver(DestructionObserver* observer); 137 138 // Associates a sync point to this stub. When the stub is destroyed, it will 139 // retire all sync points that haven't been previously retired. 140 void AddSyncPoint(uint32 sync_point); 141 142 void SetPreemptByFlag(scoped_refptr<gpu::PreemptionFlag> flag); 143 144 void SetLatencyInfoCallback(const LatencyInfoCallback& callback); 145 146 void MarkContextLost(); 147 148 uint64 GetMemoryUsage() const; 149 150 private: 151 GpuMemoryManager* GetMemoryManager() const; 152 bool MakeCurrent(); 153 void Destroy(); 154 155 // Cleans up and sends reply if OnInitialize failed. 156 void OnInitializeFailed(IPC::Message* reply_message); 157 158 // Message handlers: 159 void OnInitialize(base::SharedMemoryHandle shared_state_shm, 160 IPC::Message* reply_message); 161 void OnSetGetBuffer(int32 shm_id, IPC::Message* reply_message); 162 void OnProduceFrontBuffer(const gpu::Mailbox& mailbox); 163 void OnGetState(IPC::Message* reply_message); 164 void OnWaitForTokenInRange(int32 start, 165 int32 end, 166 IPC::Message* reply_message); 167 void OnWaitForGetOffsetInRange(int32 start, 168 int32 end, 169 IPC::Message* reply_message); 170 void OnAsyncFlush(int32 put_offset, uint32 flush_count); 171 void OnEcho(const IPC::Message& message); 172 void OnRescheduled(); 173 void OnRegisterTransferBuffer(int32 id, 174 base::SharedMemoryHandle transfer_buffer, 175 uint32 size); 176 void OnDestroyTransferBuffer(int32 id); 177 void OnGetTransferBuffer(int32 id, IPC::Message* reply_message); 178 179 void OnCreateVideoDecoder(media::VideoCodecProfile profile, 180 int32 route_id, 181 IPC::Message* reply_message); 182 void OnCreateVideoEncoder(media::VideoFrame::Format input_format, 183 const gfx::Size& input_visible_size, 184 media::VideoCodecProfile output_profile, 185 uint32 initial_bitrate, 186 int32 route_id, 187 IPC::Message* reply_message); 188 189 void OnSetSurfaceVisible(bool visible); 190 191 void OnEnsureBackbuffer(); 192 193 void OnRetireSyncPoint(uint32 sync_point); 194 bool OnWaitSyncPoint(uint32 sync_point); 195 void OnSyncPointRetired(); 196 void OnSignalSyncPoint(uint32 sync_point, uint32 id); 197 void OnSignalSyncPointAck(uint32 id); 198 void OnSignalQuery(uint32 query, uint32 id); 199 200 void OnSetClientHasMemoryAllocationChangedCallback(bool has_callback); 201 202 void OnRegisterGpuMemoryBuffer(int32 id, 203 gfx::GpuMemoryBufferHandle gpu_memory_buffer, 204 uint32 width, 205 uint32 height, 206 uint32 internalformat); 207 void OnDestroyGpuMemoryBuffer(int32 id); 208 209 void OnCommandProcessed(); 210 void OnParseError(); 211 void OnSetLatencyInfo(const std::vector<ui::LatencyInfo>& latency_info); 212 void OnCreateStreamTexture( 213 uint32 texture_id, int32 stream_id, bool* succeeded); 214 215 void ReportState(); 216 217 // Wrapper for GpuScheduler::PutChanged that sets the crash report URL. 218 void PutChanged(); 219 220 // Poll the command buffer to execute work. 221 void PollWork(); 222 223 // Whether this command buffer needs to be polled again in the future. 224 bool HasMoreWork(); 225 226 void ScheduleDelayedWork(int64 delay); 227 228 bool CheckContextLost(); 229 void CheckCompleteWaits(); 230 231 // The lifetime of objects of this class is managed by a GpuChannel. The 232 // GpuChannels destroy all the GpuCommandBufferStubs that they own when they 233 // are destroyed. So a raw pointer is safe. 234 GpuChannel* channel_; 235 236 // The group of contexts that share namespaces with this context. 237 scoped_refptr<gpu::gles2::ContextGroup> context_group_; 238 239 gfx::GLSurfaceHandle handle_; 240 gfx::Size initial_size_; 241 gpu::gles2::DisallowedFeatures disallowed_features_; 242 std::vector<int32> requested_attribs_; 243 gfx::GpuPreference gpu_preference_; 244 bool use_virtualized_gl_context_; 245 int32 route_id_; 246 int32 surface_id_; 247 bool software_; 248 uint32 last_flush_count_; 249 250 scoped_ptr<gpu::CommandBufferService> command_buffer_; 251 scoped_ptr<gpu::gles2::GLES2Decoder> decoder_; 252 scoped_ptr<gpu::GpuScheduler> scheduler_; 253 scoped_refptr<gfx::GLSurface> surface_; 254 scoped_ptr<gpu::GpuControlService> gpu_control_service_; 255 256 scoped_ptr<GpuMemoryManagerClientState> memory_manager_client_state_; 257 // The last memory allocation received from the GpuMemoryManager (used to 258 // elide redundant work). 259 bool last_memory_allocation_valid_; 260 gpu::MemoryAllocation last_memory_allocation_; 261 262 GpuWatchdog* watchdog_; 263 264 ObserverList<DestructionObserver> destruction_observers_; 265 266 // A queue of sync points associated with this stub. 267 std::deque<uint32> sync_points_; 268 int sync_point_wait_count_; 269 270 bool delayed_work_scheduled_; 271 uint64 previous_messages_processed_; 272 base::TimeTicks last_idle_time_; 273 274 scoped_refptr<gpu::PreemptionFlag> preemption_flag_; 275 276 LatencyInfoCallback latency_info_callback_; 277 278 GURL active_url_; 279 size_t active_url_hash_; 280 281 size_t total_gpu_memory_; 282 scoped_ptr<WaitForCommandState> wait_for_token_; 283 scoped_ptr<WaitForCommandState> wait_for_get_offset_; 284 285 DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferStub); 286 }; 287 288 } // namespace content 289 290 #endif // CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_ 291