Mus: Move InProcessCommandBuffer and GLInProcessContext to gpu/ipc

gpu/ipc/in_process_command_buffer.cc

 // 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.
 
-#include "gpu/command_buffer/service/in_process_command_buffer.h"
+#include "gpu/ipc/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 132 matching lines @@
 
 InProcessCommandBuffer::Service::Service()
     : gpu_driver_bug_workarounds_(base::CommandLine::ForCurrentProcess()) {}
 
 InProcessCommandBuffer::Service::Service(const GpuPreferences& gpu_preferences)
     : gpu_preferences_(gpu_preferences),
       gpu_driver_bug_workarounds_(base::CommandLine::ForCurrentProcess()) {}
 
 InProcessCommandBuffer::Service::~Service() {}
 
-const gpu::GpuPreferences&
-InProcessCommandBuffer::Service::gpu_preferences() {
+const gpu::GpuPreferences& InProcessCommandBuffer::Service::gpu_preferences() {
   return gpu_preferences_;
 }
 
 const gpu::GpuDriverBugWorkarounds&
 InProcessCommandBuffer::Service::gpu_driver_bug_workarounds() {
   return gpu_driver_bug_workarounds_;
 }
 
 scoped_refptr<gl::GLShareGroup> InProcessCommandBuffer::Service::share_group() {
   if (!share_group_.get())
@@ skipping 138 matching lines @@
   transfer_buffer_manager_ = manager;
   manager->Initialize();
 
   std::unique_ptr<CommandBufferService> command_buffer(
       new CommandBufferService(transfer_buffer_manager_.get()));
   command_buffer->SetPutOffsetChangeCallback(base::Bind(
       &InProcessCommandBuffer::PumpCommandsOnGpuThread, gpu_thread_weak_ptr_));
   command_buffer->SetParseErrorCallback(base::Bind(
       &InProcessCommandBuffer::OnContextLostOnGpuThread, gpu_thread_weak_ptr_));
 
-  gl_share_group_ = params.context_group
-                        ? params.context_group->gl_share_group_
-                        : service_->share_group();
+  gl_share_group_ = params.context_group ? params.context_group->gl_share_group_
+                                         : service_->share_group();
 
   bool bind_generates_resource = false;
   scoped_refptr<gles2::FeatureInfo> feature_info =
       new gles2::FeatureInfo(service_->gpu_driver_bug_workarounds());
   decoder_.reset(gles2::GLES2Decoder::Create(
       params.context_group
           ? params.context_group->decoder_->GetContextGroup()
           : new gles2::ContextGroup(
                 service_->gpu_preferences(), service_->mailbox_manager(), NULL,
                 service_->shader_translator_cache(),
@@ skipping 32 matching lines @@
           .use_virtualized_gl_contexts) {
     context_ = gl_share_group_->GetSharedContext(surface_.get());
     if (!context_.get()) {
       context_ = gl::init::CreateGLContext(
           gl_share_group_.get(), surface_.get(),
           GenerateGLContextAttribs(
               params.attribs, decoder_->GetContextGroup()->gpu_preferences()));
       gl_share_group_->SetSharedContext(surface_.get(), context_.get());
     }
 
-    context_ = new GLContextVirtual(
-        gl_share_group_.get(), context_.get(), decoder_->AsWeakPtr());
+    context_ = new GLContextVirtual(gl_share_group_.get(), context_.get(),
+                                    decoder_->AsWeakPtr());
     if (context_->Initialize(
             surface_.get(),
             GenerateGLContextAttribs(
                 params.attribs,
                 decoder_->GetContextGroup()->gpu_preferences()))) {
       VLOG(1) << "Created virtual GL context.";
     } else {
       context_ = NULL;
     }
   } else {
@@ skipping 18 matching lines @@
   if (!decoder_->GetContextGroup()->has_program_cache() &&
       !decoder_->GetContextGroup()
            ->feature_info()
            ->workarounds()
            .disable_program_cache) {
     decoder_->GetContextGroup()->set_program_cache(service_->program_cache());
   }
 
   gles2::DisallowedFeatures disallowed_features;
   disallowed_features.gpu_memory_manager = true;
-  if (!decoder_->Initialize(surface_,
-                            context_,
-                            params.is_offscreen,
-                            disallowed_features,
-                            params.attribs)) {
+  if (!decoder_->Initialize(surface_, context_, params.is_offscreen,
+                            disallowed_features, params.attribs)) {
     LOG(ERROR) << "Could not initialize decoder.";
     DestroyOnGpuThread();
     return false;
   }
   *params.capabilities = decoder_->GetCapabilities();
 
   decoder_->SetFenceSyncReleaseCallback(
       base::Bind(&InProcessCommandBuffer::FenceSyncReleaseOnGpuThread,
                  base::Unretained(this)));
   decoder_->SetWaitFenceSyncCallback(
@@ skipping 153 matching lines @@
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   SyncPointManager* sync_manager = service_->sync_point_manager();
   const uint32_t order_num =
       sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
-                                  gpu_thread_weak_ptr_,
-                                  put_offset,
-                                  order_num);
+                                  gpu_thread_weak_ptr_, put_offset, order_num);
   QueueTask(task);
 
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
 void InProcessCommandBuffer::WaitForTokenInRange(int32_t start, int32_t end) {
@@ skipping 49 matching lines @@
     int32_t* id) {
   CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   return command_buffer_->CreateTransferBuffer(size, id);
 }
 
 void InProcessCommandBuffer::DestroyTransferBuffer(int32_t id) {
   CheckSequencedThread();
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::DestroyTransferBufferOnGpuThread,
-                 base::Unretained(this),
-                 id);
+                 base::Unretained(this), id);
 
   QueueTask(task);
 }
 
 void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32_t id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 void InProcessCommandBuffer::SetGpuControlClient(GpuControlClient* client) {
@@ skipping 19 matching lines @@
 
   DCHECK(gpu::IsGpuMemoryBufferFormatSupported(gpu_memory_buffer->GetFormat(),
                                                capabilities_));
   DCHECK(gpu::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
 
   // This handle is owned by the GPU thread and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // queuing of the CreateImage task below.
   bool requires_sync_point = false;
-  gfx::GpuMemoryBufferHandle handle =
-      ShareGpuMemoryBufferToGpuThread(gpu_memory_buffer->GetHandle(),
-                                      &requires_sync_point);
+  gfx::GpuMemoryBufferHandle handle = ShareGpuMemoryBufferToGpuThread(
+      gpu_memory_buffer->GetHandle(), &requires_sync_point);
 
   SyncPointManager* sync_manager = service_->sync_point_manager();
   const uint32_t order_num =
       sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
 
   uint64_t fence_sync = 0;
   if (requires_sync_point) {
     fence_sync = GenerateFenceSyncRelease();
 
     // Previous fence syncs should be flushed already.
     DCHECK_EQ(fence_sync - 1, flushed_fence_sync_release_);
   }
 
-  QueueTask(base::Bind(&InProcessCommandBuffer::CreateImageOnGpuThread,
-                       base::Unretained(this), new_id, handle,
-                       gfx::Size(width, height), gpu_memory_buffer->GetFormat(),
-                       internalformat, order_num, fence_sync));
+  QueueTask(base::Bind(
+      &InProcessCommandBuffer::CreateImageOnGpuThread, base::Unretained(this),
+      new_id, handle, gfx::Size(base::checked_cast<int>(width),
+                                base::checked_cast<int>(height)),
+      gpu_memory_buffer->GetFormat(),
+      base::checked_cast<uint32_t>(internalformat), order_num, fence_sync));
 
   if (fence_sync) {
     flushed_fence_sync_release_ = fence_sync;
     SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
                          GetCommandBufferID(), fence_sync);
     sync_token.SetVerifyFlush();
     gpu_memory_buffer_manager_->SetDestructionSyncToken(gpu_memory_buffer,
                                                         sync_token);
   }
 
@@ skipping 62 matching lines @@
 
   if (fence_sync) {
     sync_point_client_->ReleaseFenceSync(fence_sync);
   }
 }
 
 void InProcessCommandBuffer::DestroyImage(int32_t id) {
   CheckSequencedThread();
 
   QueueTask(base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
-                       base::Unretained(this),
-                       id));
+                       base::Unretained(this), id));
 }
 
 void InProcessCommandBuffer::DestroyImageOnGpuThread(int32_t id) {
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
     return;
   }
 
   image_manager->RemoveImage(id);
 }
 
 int32_t InProcessCommandBuffer::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
   std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
-          gfx::Size(width, height),
+          gfx::Size(base::checked_cast<int>(width),
+                    base::checked_cast<int>(height)),
           gpu::DefaultBufferFormatForImageFormat(internalformat),
           gfx::BufferUsage::SCANOUT, gpu::kNullSurfaceHandle));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
 void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint64_t release) {
   DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
@@ skipping 40 matching lines @@
 
 void InProcessCommandBuffer::DescheduleUntilFinishedOnGpuThread() {
   NOTIMPLEMENTED();
 }
 
 void InProcessCommandBuffer::RescheduleAfterFinishedOnGpuThread() {
   NOTIMPLEMENTED();
 }
 
 void InProcessCommandBuffer::SignalSyncTokenOnGpuThread(
-    const SyncToken& sync_token, const base::Closure& callback) {
+    const SyncToken& sync_token,
+    const base::Closure& callback) {
   gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
   DCHECK(sync_point_manager);
 
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager->GetSyncPointClientState(
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (!release_state) {
     callback.Run();
     return;
   }
 
   sync_point_client_->WaitOutOfOrder(
       release_state.get(), sync_token.release_count(), WrapCallback(callback));
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
                                          const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
-                       base::Unretained(this),
-                       query_id,
+                       base::Unretained(this), query_id,
                        WrapCallback(callback)));
 }
 
 void InProcessCommandBuffer::SignalQueryOnGpuThread(
     unsigned query_id,
     const base::Closure& callback) {
   gles2::QueryManager* query_manager_ = decoder_->GetQueryManager();
   DCHECK(query_manager_);
 
   gles2::QueryManager::Query* query = query_manager_->GetQuery(query_id);
@@ skipping 37 matching lines @@
 }
 
 bool InProcessCommandBuffer::IsFenceSyncFlushReceived(uint64_t release) {
   return IsFenceSyncFlushed(release);
 }
 
 void InProcessCommandBuffer::SignalSyncToken(const SyncToken& sync_token,
                                              const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalSyncTokenOnGpuThread,
-                       base::Unretained(this),
-                       sync_token,
+                       base::Unretained(this), sync_token,
                        WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
     const SyncToken* sync_token) {
   return sync_token->namespace_id() == GetNamespaceID();
 }
 
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
   CheckSequencedThread();
@@ skipping 81 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu