Mus: Move InProcessCommandBuffer and GLInProcessContext to gpu/ipc

gpu/command_buffer/service/in_process_command_buffer.h

Index: gpu/command_buffer/service/in_process_command_buffer.h
diff --git a/gpu/command_buffer/service/in_process_command_buffer.h b/gpu/command_buffer/service/in_process_command_buffer.h
deleted file mode 100644
index ad98b6eb7f479b722e5ba0cfb90b0a386fcc2c3e..0000000000000000000000000000000000000000
--- a/gpu/command_buffer/service/in_process_command_buffer.h
+++ /dev/null
@@ -1,315 +0,0 @@
-// Copyright 2013 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_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
-#define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <vector>
-
-#include "base/atomic_sequence_num.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/containers/scoped_ptr_hash_map.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "gpu/command_buffer/client/gpu_control.h"
-#include "gpu/command_buffer/common/command_buffer.h"
-#include "gpu/command_buffer/service/gpu_preferences.h"
-#include "gpu/config/gpu_driver_bug_workarounds.h"
-#include "gpu/gpu_export.h"
-#include "ui/gfx/gpu_memory_buffer.h"
-#include "ui/gfx/native_widget_types.h"
-#include "ui/gl/gl_surface.h"
-#include "ui/gl/gpu_preference.h"
-
-namespace base {
-class SequenceChecker;
-}
-
-namespace gl {
-class GLContext;
-class GLShareGroup;
-class GLSurface;
-}
-
-namespace gfx {
-class Size;
-}
-
-namespace gpu {
-class SyncPointClient;
-class SyncPointOrderData;
-class SyncPointManager;
-
-namespace gles2 {
-struct ContextCreationAttribHelper;
-class FramebufferCompletenessCache;
-class GLES2Decoder;
-class MailboxManager;
-class ProgramCache;
-class ShaderTranslatorCache;
-}
-
-class CommandBufferServiceBase;
-class GpuMemoryBufferManager;
-class CommandExecutor;
-class ImageFactory;
-class TransferBufferManagerInterface;
-
-// This class provides a thread-safe interface to the global GPU service (for
-// example GPU thread) when being run in single process mode.
-// However, the behavior for accessing one context (i.e. one instance of this
-// class) from different client threads is undefined.
-class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
-                                          public GpuControl {
- public:
-  class Service;
-  explicit InProcessCommandBuffer(const scoped_refptr<Service>& service);
-  ~InProcessCommandBuffer() override;
-
-  // If |surface| is not null, use it directly; in this case, the command
-  // buffer gpu thread must be the same as the client thread. Otherwise create
-  // a new GLSurface.
-  bool Initialize(scoped_refptr<gl::GLSurface> surface,
-                  bool is_offscreen,
-                  gfx::AcceleratedWidget window,
-                  const gles2::ContextCreationAttribHelper& attribs,
-                  InProcessCommandBuffer* share_group,
-                  GpuMemoryBufferManager* gpu_memory_buffer_manager,
-                  ImageFactory* image_factory,
-                  scoped_refptr<base::SingleThreadTaskRunner> task_runner);
-
-  // 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;
-  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::error::Error GetLastError() override;
-
-  // GpuControl implementation:
-  // NOTE: The GpuControlClient will be called on the client thread.
-  void SetGpuControlClient(GpuControlClient*) override;
-  gpu::Capabilities GetCapabilities() override;
-  int32_t CreateImage(ClientBuffer buffer,
-                      size_t width,
-                      size_t height,
-                      unsigned internalformat) override;
-  void DestroyImage(int32_t id) override;
-  int32_t CreateGpuMemoryBufferImage(size_t width,
-                                     size_t height,
-                                     unsigned internalformat,
-                                     unsigned usage) override;
-  void SignalQuery(uint32_t query_id, const base::Closure& callback) override;
-  void SetLock(base::Lock*) override;
-  void EnsureWorkVisible() override;
-  CommandBufferNamespace GetNamespaceID() const override;
-  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;
-  void SignalSyncToken(const SyncToken& sync_token,
-                       const base::Closure& callback) override;
-  bool CanWaitUnverifiedSyncToken(const SyncToken* sync_token) override;
-
-  // The serializer interface to the GPU service (i.e. thread).
-  class Service {
-   public:
-    Service();
-    Service(const gpu::GpuPreferences& gpu_preferences);
-    virtual ~Service();
-
-    virtual void AddRef() const = 0;
-    virtual void Release() const = 0;
-
-    // Queues a task to run as soon as possible.
-    virtual void ScheduleTask(const base::Closure& task) = 0;
-
-    // Schedules |callback| to run at an appropriate time for performing delayed
-    // work.
-    virtual void ScheduleDelayedWork(const base::Closure& task) = 0;
-
-    virtual bool UseVirtualizedGLContexts() = 0;
-    virtual scoped_refptr<gles2::ShaderTranslatorCache>
-        shader_translator_cache() = 0;
-    virtual scoped_refptr<gles2::FramebufferCompletenessCache>
-    framebuffer_completeness_cache() = 0;
-    virtual SyncPointManager* sync_point_manager() = 0;
-    const GpuPreferences& gpu_preferences();
-    const GpuDriverBugWorkarounds& gpu_driver_bug_workarounds();
-    scoped_refptr<gl::GLShareGroup> share_group();
-    scoped_refptr<gles2::MailboxManager> mailbox_manager();
-    gpu::gles2::ProgramCache* program_cache();
-
-   private:
-    const GpuPreferences gpu_preferences_;
-    const GpuDriverBugWorkarounds gpu_driver_bug_workarounds_;
-    scoped_refptr<gl::GLShareGroup> share_group_;
-    scoped_refptr<gles2::MailboxManager> mailbox_manager_;
-    std::unique_ptr<gpu::gles2::ProgramCache> program_cache_;
-  };
-
- private:
-  struct InitializeOnGpuThreadParams {
-    bool is_offscreen;
-    gfx::AcceleratedWidget window;
-    const gles2::ContextCreationAttribHelper& attribs;
-    gpu::Capabilities* capabilities;  // Ouptut.
-    InProcessCommandBuffer* context_group;
-    ImageFactory* image_factory;
-
-    InitializeOnGpuThreadParams(
-        bool is_offscreen,
-        gfx::AcceleratedWidget window,
-        const gles2::ContextCreationAttribHelper& attribs,
-        gpu::Capabilities* capabilities,
-        InProcessCommandBuffer* share_group,
-        ImageFactory* image_factory)
-        : is_offscreen(is_offscreen),
-          window(window),
-          attribs(attribs),
-          capabilities(capabilities),
-          context_group(share_group),
-          image_factory(image_factory) {}
-  };
-
-  bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params);
-  void Destroy();
-  bool DestroyOnGpuThread();
-  void FlushOnGpuThread(int32_t put_offset, uint32_t order_num);
-  void ScheduleDelayedWorkOnGpuThread();
-  bool MakeCurrent();
-  base::Closure WrapCallback(const base::Closure& callback);
-  State GetStateFast();
-  void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
-  void CheckSequencedThread();
-  void FenceSyncReleaseOnGpuThread(uint64_t release);
-  bool WaitFenceSyncOnGpuThread(gpu::CommandBufferNamespace namespace_id,
-                                gpu::CommandBufferId command_buffer_id,
-                                uint64_t release);
-  void DescheduleUntilFinishedOnGpuThread();
-  void RescheduleAfterFinishedOnGpuThread();
-  void SignalSyncTokenOnGpuThread(const SyncToken& sync_token,
-                                  const base::Closure& callback);
-  void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback);
-  void DestroyTransferBufferOnGpuThread(int32_t id);
-  void CreateImageOnGpuThread(int32_t id,
-                              const gfx::GpuMemoryBufferHandle& handle,
-                              const gfx::Size& size,
-                              gfx::BufferFormat format,
-                              uint32_t internalformat,
-                              uint32_t order_num,
-                              uint64_t fence_sync);
-  void DestroyImageOnGpuThread(int32_t id);
-  void SetGetBufferOnGpuThread(int32_t shm_id, base::WaitableEvent* completion);
-
-  // Callbacks on the gpu thread.
-  void OnContextLostOnGpuThread();
-  void PumpCommandsOnGpuThread();
-  void PerformDelayedWorkOnGpuThread();
-  // Callback implementations on the client thread.
-  void OnContextLost();
-
-  const CommandBufferId command_buffer_id_;
-
-  // Members accessed on the gpu thread (possibly with the exception of
-  // creation):
-  scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
-  scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
-  std::unique_ptr<CommandExecutor> executor_;
-  std::unique_ptr<gles2::GLES2Decoder> decoder_;
-  scoped_refptr<gl::GLContext> context_;
-  scoped_refptr<gl::GLSurface> surface_;
-  scoped_refptr<SyncPointOrderData> sync_point_order_data_;
-  std::unique_ptr<SyncPointClient> sync_point_client_;
-  base::Closure context_lost_callback_;
-  // Used to throttle PerformDelayedWorkOnGpuThread.
-  bool delayed_work_pending_;
-  ImageFactory* image_factory_;
-
-  // Members accessed on the client thread:
-  GpuControlClient* gpu_control_client_;
-#if DCHECK_IS_ON()
-  bool context_lost_;
-#endif
-  State last_state_;
-  int32_t last_put_offset_;
-  gpu::Capabilities capabilities_;
-  GpuMemoryBufferManager* gpu_memory_buffer_manager_;
-  base::AtomicSequenceNumber next_image_id_;
-  uint64_t next_fence_sync_release_;
-  uint64_t flushed_fence_sync_release_;
-
-  // Accessed on both threads:
-  std::unique_ptr<CommandBufferServiceBase> command_buffer_;
-  base::Lock command_buffer_lock_;
-  base::WaitableEvent flush_event_;
-  scoped_refptr<Service> service_;
-  State state_after_last_flush_;
-  base::Lock state_after_last_flush_lock_;
-  scoped_refptr<gl::GLShareGroup> gl_share_group_;
-  base::WaitableEvent fence_sync_wait_event_;
-
-  // Only used with explicit scheduling and the gpu thread is the same as
-  // the client thread.
-  std::unique_ptr<base::SequenceChecker> sequence_checker_;
-
-  base::WeakPtr<InProcessCommandBuffer> client_thread_weak_ptr_;
-  base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_;
-  base::WeakPtrFactory<InProcessCommandBuffer> client_thread_weak_ptr_factory_;
-  base::WeakPtrFactory<InProcessCommandBuffer> gpu_thread_weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(InProcessCommandBuffer);
-};
-
-// Default Service class when a null service is used.
-class GPU_EXPORT GpuInProcessThread
-    : public base::Thread,
-      public NON_EXPORTED_BASE(InProcessCommandBuffer::Service),
-      public base::RefCountedThreadSafe<GpuInProcessThread> {
- public:
-  explicit GpuInProcessThread(SyncPointManager* sync_point_manager);
-
-  void AddRef() const override;
-  void Release() const override;
-  void ScheduleTask(const base::Closure& task) override;
-  void ScheduleDelayedWork(const base::Closure& callback) override;
-  bool UseVirtualizedGLContexts() override;
-  scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
-      override;
-  scoped_refptr<gles2::FramebufferCompletenessCache>
-  framebuffer_completeness_cache() override;
-  SyncPointManager* sync_point_manager() override;
-
- private:
-  ~GpuInProcessThread() override;
-  friend class base::RefCountedThreadSafe<GpuInProcessThread>;
-
-  SyncPointManager* sync_point_manager_;  // Non-owning.
-  scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
-  scoped_refptr<gpu::gles2::FramebufferCompletenessCache>
-      framebuffer_completeness_cache_;
-  DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_