content/common/gpu/gpu_command_buffer_stub.h

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