Pass initial size and GPU preference via context attributes

gpu/command_buffer/service/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 <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 233 matching lines @@
   if (!MakeCurrent())
     return;
 
   executor_->PutChanged();
 }
 
 bool InProcessCommandBuffer::Initialize(
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
-    const gfx::Size& size,
     const gles2::ContextCreationAttribHelper& attribs,
-    gl::GpuPreference gpu_preference,
     InProcessCommandBuffer* share_group,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   DCHECK(!share_group || service_.get() == share_group->service_.get());
 
   if (surface) {
     // GPU thread must be the same as client thread due to GLSurface not being
     // thread safe.
     sequence_checker_.reset(new base::SequenceChecker);
     surface_ = surface;
   } else {
     origin_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     client_thread_weak_ptr_ = client_thread_weak_ptr_factory_.GetWeakPtr();
   }
 
   gpu::Capabilities capabilities;
-  InitializeOnGpuThreadParams params(is_offscreen,
-                                     window,
-                                     size,
-                                     attribs,
-                                     gpu_preference,
-                                     &capabilities,
-                                     share_group,
-                                     image_factory);
+  InitializeOnGpuThreadParams params(is_offscreen, window, attribs,
+                                     &capabilities, share_group, image_factory);
 
   base::Callback<bool(void)> init_task =
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
-                 base::Unretained(this),
-                 params);
+                 base::Unretained(this), params);
 
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   bool result = false;
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
   completion.Wait();
 
   gpu_memory_buffer_manager_ = gpu_memory_buffer_manager;
 
   if (result) {
     capabilities_ = capabilities;
     capabilities_.image = capabilities_.image && gpu_memory_buffer_manager_;
   }
 
   return result;
 }
 
 bool InProcessCommandBuffer::InitializeOnGpuThread(
     const InitializeOnGpuThreadParams& params) {
   CheckSequencedThread();
   gpu_thread_weak_ptr_ = gpu_thread_weak_ptr_factory_.GetWeakPtr();
 
-  DCHECK(params.size.width() >= 0 && params.size.height() >= 0);
-
   TransferBufferManager* manager = new TransferBufferManager(nullptr);
   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_));
@@ skipping 17 matching lines @@
   executor_.reset(new CommandExecutor(command_buffer.get(), decoder_.get(),
                                       decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &CommandExecutor::SetGetBuffer, base::Unretained(executor_.get())));
   command_buffer_ = std::move(command_buffer);
 
   decoder_->set_engine(executor_.get());
 
   if (!surface_.get()) {
     if (params.is_offscreen)
-      surface_ = gl::init::CreateOffscreenGLSurface(params.size);
+      surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
     else
       surface_ = gl::init::CreateViewGLSurface(params.window);
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
   sync_point_order_data_ = SyncPointOrderData::Create();
   sync_point_client_ = service_->sync_point_manager()->CreateSyncPointClient(
       sync_point_order_data_, GetNamespaceID(), GetCommandBufferID());
 
   if (service_->UseVirtualizedGLContexts() ||
       decoder_->GetContextGroup()
           ->feature_info()
           ->workarounds()
           .use_virtualized_gl_contexts) {
     context_ = gl_share_group_->GetSharedContext();
     if (!context_.get()) {
       context_ = gl::init::CreateGLContext(
-          gl_share_group_.get(), surface_.get(), params.gpu_preference);
+          gl_share_group_.get(), surface_.get(), params.attribs.gpu_preference);
       gl_share_group_->SetSharedContext(context_.get());
     }
 
     context_ = new GLContextVirtual(
         gl_share_group_.get(), context_.get(), decoder_->AsWeakPtr());
-    if (context_->Initialize(surface_.get(), params.gpu_preference)) {
+    if (context_->Initialize(surface_.get(), params.attribs.gpu_preference)) {
       VLOG(1) << "Created virtual GL context.";
     } else {
       context_ = NULL;
     }
   } else {
     context_ = gl::init::CreateGLContext(gl_share_group_.get(), surface_.get(),
-                                         params.gpu_preference);
+                                         params.attribs.gpu_preference);
   }
 
   if (!context_.get()) {
     LOG(ERROR) << "Could not create GLContext.";
     DestroyOnGpuThread();
     return false;
   }
 
   if (!context_->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Could not make context current.";
     DestroyOnGpuThread();
     return false;
   }
 
   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,
-                            params.size,
                             disallowed_features,
                             params.attribs)) {
     LOG(ERROR) << "Could not initialize decoder.";
     DestroyOnGpuThread();
     return false;
   }
   *params.capabilities = decoder_->GetCapabilities();
 
   decoder_->SetFenceSyncReleaseCallback(
       base::Bind(&InProcessCommandBuffer::FenceSyncReleaseOnGpuThread,
@@ skipping 657 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu