gpu: Thread-safe command buffer state lookup.

gpu/ipc/client/command_buffer_proxy_impl.h

 // 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 GPU_IPC_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 #define GPU_IPC_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 78 matching lines @@
       const GURL& active_url,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~CommandBufferProxyImpl() override;
 
   // IPC::Listener implementation:
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnChannelError() override;
 
   // CommandBuffer implementation:
   State GetLastState() override;
-  int32_t GetLastToken() override;
   void Flush(int32_t put_offset) override;
   void OrderingBarrier(int32_t put_offset) override;
-  void WaitForTokenInRange(int32_t start, int32_t end) override;
-  void WaitForGetOffsetInRange(int32_t start, int32_t end) override;
+  State WaitForTokenInRange(int32_t start, int32_t end) override;
+  State WaitForGetOffsetInRange(int32_t start, int32_t end) override;
   void SetGetBuffer(int32_t shm_id) override;
   scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
                                                   int32_t* id) override;
   void DestroyTransferBuffer(int32_t id) override;
 
   // gpu::GpuControl implementation:
   void SetGpuControlClient(GpuControlClient* client) override;
   gpu::Capabilities GetCapabilities() override;
   int32_t CreateImage(ClientBuffer buffer,
                       size_t width,
                       size_t height,
                       unsigned internal_format) override;
   void DestroyImage(int32_t id) override;
   int32_t CreateGpuMemoryBufferImage(size_t width,
                                      size_t height,
                                      unsigned internal_format,
                                      unsigned usage) override;
   void SignalQuery(uint32_t query, const base::Closure& callback) override;
   void SetLock(base::Lock* lock) override;
   void EnsureWorkVisible() override;
   gpu::CommandBufferNamespace GetNamespaceID() const override;
   gpu::CommandBufferId GetCommandBufferID() const override;
   int32_t GetExtraCommandBufferData() const override;
   uint64_t GenerateFenceSyncRelease() override;
   bool IsFenceSyncRelease(uint64_t release) override;
   bool IsFenceSyncFlushed(uint64_t release) override;
   bool IsFenceSyncFlushReceived(uint64_t release) override;
+  bool IsFenceSyncReleased(uint64_t release) override;
   void SignalSyncToken(const gpu::SyncToken& sync_token,
                        const base::Closure& callback) override;
   bool CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) override;
 
   void TakeFrontBuffer(const gpu::Mailbox& mailbox);
   void ReturnFrontBuffer(const gpu::Mailbox& mailbox,
                          const gpu::SyncToken& sync_token,
                          bool is_lost);
 
   void AddDeletionObserver(DeletionObserver* observer);
   void RemoveDeletionObserver(DeletionObserver* observer);
 
   bool EnsureBackbuffer();
 
   void SetOnConsoleMessageCallback(const GpuConsoleMessageCallback& callback);
 
   void SetLatencyInfo(const std::vector<ui::LatencyInfo>& latency_info);
   using SwapBuffersCompletionCallback = base::Callback<void(
       const std::vector<ui::LatencyInfo>& latency_info,
       gfx::SwapResult result,
       const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac)>;
   void SetSwapBuffersCompletionCallback(
       const SwapBuffersCompletionCallback& callback);
 
   using UpdateVSyncParametersCallback =
       base::Callback<void(base::TimeTicks timebase, base::TimeDelta interval)>;
   void SetUpdateVSyncParametersCallback(
       const UpdateVSyncParametersCallback& callback);
 
-  // TODO(apatrick): this is a temporary optimization while skia is calling
-  // ContentGLContext::MakeCurrent prior to every GL call. It saves returning 6
-  // ints redundantly when only the error is needed for the
-  // CommandBufferProxyImpl implementation.
-  gpu::error::Error GetLastError() override;
-
   int32_t route_id() const { return route_id_; }
 
   const scoped_refptr<GpuChannelHost>& channel() const { return channel_; }
 
   base::SharedMemoryHandle GetSharedStateHandle() const {
     return shared_state_shm_->handle();
   }
   uint32_t CreateStreamTexture(uint32_t texture_id);
 
  private:
@@ skipping 28 matching lines @@
   void OnUpdateVSyncParameters(base::TimeTicks timebase,
                                base::TimeDelta interval);
 
   // Updates the highest verified release fence sync.
   void UpdateVerifiedReleases(uint32_t verified_flush);
   void CleanupFlushedReleases(uint32_t highest_verified_flush_id);
 
   // Try to read an updated copy of the state from shared memory, and calls
   // OnGpuStateError() if the new state has an error.
   void TryUpdateState();
+  // Like above but calls the error handler and disconnects channel by posting
+  // a task.
+  void TryUpdateStateThreadSafe();
   // Like the above but does not call the error event handler if the new state
   // has an error.
   void TryUpdateStateDontReportError();
   // Sets the state, and calls OnGpuStateError() if the new state has an error.
   void SetStateFromSyncReply(const gpu::CommandBuffer::State& state);
 
   // Loses the context after we received an invalid reply from the GPU
   // process.
   void OnGpuSyncReplyError();
 
   // Loses the context when receiving a message from the GPU process.
   void OnGpuAsyncMessageError(gpu::error::ContextLostReason reason,
                               gpu::error::Error error);
 
   // Loses the context after we receive an error state from the GPU process.
   void OnGpuStateError();
 
   // Sets an error on the last_state_ and loses the context due to client-side
   // errors.
   void OnClientError(gpu::error::Error error);
 
   // Helper methods, don't call these directly.
   void DisconnectChannelInFreshCallStack();
   void LockAndDisconnectChannel();
   void DisconnectChannel();
 
   // The shared memory area used to update state.
   gpu::CommandBufferSharedState* shared_state() const;
 
+  // The shared memory area used to update state.
+  std::unique_ptr<base::SharedMemory> shared_state_shm_;
+
+  // The last cached state received from the service.
+  State last_state_;
+
+  // Lock to access shared state e.g. sync token release count across multiple
+  // threads. This allows tracking command buffer progress from another thread.
+  base::Lock last_state_lock_;
+
   // There should be a lock_ if this is going to be used across multiple
   // threads, or we guarantee it is used by a single thread by using a thread
   // checker if no lock_ is set.
   base::Lock* lock_;
   base::ThreadChecker lockless_thread_checker_;
 
   // Client that wants to listen for important events on the GpuControl.
   gpu::GpuControlClient* gpu_control_client_;
 
   // Unowned list of DeletionObservers.
   base::ObserverList<DeletionObserver> deletion_observers_;
 
-  // The last cached state received from the service.
-  State last_state_;
-
-  // The shared memory area used to update state.
-  std::unique_ptr<base::SharedMemory> shared_state_shm_;
-
   scoped_refptr<GpuChannelHost> channel_;
   const gpu::CommandBufferId command_buffer_id_;
   const int32_t route_id_;
   const int32_t stream_id_;
   uint32_t flush_count_;
   int32_t last_put_offset_;
   int32_t last_barrier_put_offset_;
 
   // Next generated fence sync.
   uint64_t next_fence_sync_release_;
@@ skipping 22 matching lines @@
 
   base::WeakPtr<CommandBufferProxyImpl> weak_this_;
   scoped_refptr<base::SequencedTaskRunner> callback_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBufferProxyImpl);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_IPC_CLIENT_COMMAND_BUFFER_PROXY_IMPL_H_