Pass initial size and GPU preference via context attributes

gpu/command_buffer/client/gl_in_process_context.cc

 // 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.
 
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 36 matching lines @@
     : public GLInProcessContext,
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   GLInProcessContextImpl();
   ~GLInProcessContextImpl() override;
 
   bool Initialize(scoped_refptr<gl::GLSurface> surface,
                   bool is_offscreen,
                   GLInProcessContext* share_context,
                   gfx::AcceleratedWidget window,
-                  const gfx::Size& size,
                   const gpu::gles2::ContextCreationAttribHelper& attribs,
-                  gl::GpuPreference gpu_preference,
                   const scoped_refptr<InProcessCommandBuffer::Service>& service,
                   const SharedMemoryLimits& mem_limits,
                   GpuMemoryBufferManager* gpu_memory_buffer_manager,
                   ImageFactory* image_factory);
 
   // GLInProcessContext implementation:
   gles2::GLES2Implementation* GetImplementation() override;
   void SetLock(base::Lock* lock) override;
 
  private:
@@ skipping 20 matching lines @@
 
 void GLInProcessContextImpl::SetLock(base::Lock* lock) {
   NOTREACHED();
 }
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
     GLInProcessContext* share_context,
     gfx::AcceleratedWidget window,
-    const gfx::Size& size,
     const gles2::ContextCreationAttribHelper& attribs,
-    gl::GpuPreference gpu_preference,
     const scoped_refptr<InProcessCommandBuffer::Service>& service,
     const SharedMemoryLimits& mem_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
-  DCHECK(size.width() >= 0 && size.height() >= 0);
+  DCHECK(attribs.offscreen_framebuffer_size.width() >= 0 &&

[danakj, 2016/06/29 18:25:54]

nit: 2 dchecks, and GE

[piman, 2016/06/29 20:28:51]

Done.

+         attribs.offscreen_framebuffer_size.height() >= 0);
 
   command_buffer_.reset(new InProcessCommandBuffer(service));
 
   scoped_refptr<gles2::ShareGroup> share_group;
   InProcessCommandBuffer* share_command_buffer = nullptr;
   if (share_context) {
     GLInProcessContextImpl* impl =
         static_cast<GLInProcessContextImpl*>(share_context);
     share_group = impl->gles2_implementation_->share_group();
     share_command_buffer = impl->command_buffer_.get();
     DCHECK(share_group);
     DCHECK(share_command_buffer);
   }
 
   if (!command_buffer_->Initialize(surface,
                                    is_offscreen,
                                    window,
-                                   size,
                                    attribs,
-                                   gpu_preference,
                                    share_command_buffer,
                                    gpu_memory_buffer_manager,
                                    image_factory)) {
     DLOG(ERROR) << "Failed to initialize InProcessCommmandBuffer";
     return false;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!gles2_helper_->Initialize(mem_limits.command_buffer_size)) {
@@ skipping 49 matching lines @@
 }
 
 }  // anonymous namespace
 
 // static
 GLInProcessContext* GLInProcessContext::Create(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     scoped_refptr<gl::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
-    const gfx::Size& size,
     GLInProcessContext* share_context,
     const ::gpu::gles2::ContextCreationAttribHelper& attribs,
-    gl::GpuPreference gpu_preference,
     const SharedMemoryLimits& memory_limits,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   if (surface.get()) {
     DCHECK_EQ(surface->IsOffscreen(), is_offscreen);
-    DCHECK(surface->GetSize() == size);
     DCHECK_EQ(gfx::kNullAcceleratedWidget, window);
   }
 
   std::unique_ptr<GLInProcessContextImpl> context(new GLInProcessContextImpl);
-  if (!context->Initialize(surface, is_offscreen, share_context, window, size,
-                           attribs, gpu_preference, service, memory_limits,
+  if (!context->Initialize(surface, is_offscreen, share_context, window,
+                           attribs, service, memory_limits,
                            gpu_memory_buffer_manager, image_factory))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu