Pass initial size and GPU preference via context attributes

content/renderer/pepper/ppb_graphics_3d_impl.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 "content/renderer/pepper/ppb_graphics_3d_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 207 matching lines @@
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   if (!render_thread)
     return false;
 
   scoped_refptr<gpu::GpuChannelHost> channel =
       render_thread->EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_PEPPERPLATFORMCONTEXT3DIMPL_INITIALIZE);
   if (!channel)
     return false;
 
-  gfx::Size surface_size;
+  gpu::gles2::ContextCreationAttribHelper attrib_helper;
   std::vector<int32_t> attribs;
-  gl::GpuPreference gpu_preference = gl::PreferDiscreteGpu;
+  attrib_helper.gpu_preference = gl::PreferDiscreteGpu;
   // TODO(alokp): Change CommandBufferProxyImpl::Create()
   // interface to accept width and height in the attrib_list so that
   // we do not need to filter for width and height here.
   if (attrib_list) {
     for (const int32_t* attr = attrib_list; attr[0] != PP_GRAPHICS3DATTRIB_NONE;
          attr += 2) {
       switch (attr[0]) {
         case PP_GRAPHICS3DATTRIB_WIDTH:
-          surface_size.set_width(attr[1]);
+          attrib_helper.offscreen_framebuffer_size.set_width(attr[1]);
           break;
         case PP_GRAPHICS3DATTRIB_HEIGHT:
-          surface_size.set_height(attr[1]);
+          attrib_helper.offscreen_framebuffer_size.set_height(attr[1]);
           break;
         case PP_GRAPHICS3DATTRIB_GPU_PREFERENCE:
-          gpu_preference =
+          attrib_helper.gpu_preference =
               (attr[1] == PP_GRAPHICS3DATTRIB_GPU_PREFERENCE_LOW_POWER)
                   ? gl::PreferIntegratedGpu
                   : gl::PreferDiscreteGpu;
           break;
         case PP_GRAPHICS3DATTRIB_ALPHA_SIZE:
           has_alpha_ = attr[1] > 0;
         // fall-through
         default:
           attribs.push_back(attr[0]);
           attribs.push_back(attr[1]);
           break;
       }
     }
     attribs.push_back(PP_GRAPHICS3DATTRIB_NONE);
   }
-  gpu::gles2::ContextCreationAttribHelper attrib_helper;
   if (!attrib_helper.Parse(attribs))
     return false;
 
   gpu::CommandBufferProxyImpl* share_buffer = NULL;
   if (share_context) {
     PPB_Graphics3D_Impl* share_graphics =
         static_cast<PPB_Graphics3D_Impl*>(share_context);
     share_buffer = share_graphics->GetCommandBufferProxy();
   }
 
   command_buffer_ = gpu::CommandBufferProxyImpl::Create(
-      std::move(channel), gpu::kNullSurfaceHandle, surface_size, share_buffer,
-      gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::NORMAL,
-      attrib_helper, GURL::EmptyGURL(), gpu_preference,
-      base::ThreadTaskRunnerHandle::Get());
+      std::move(channel), gpu::kNullSurfaceHandle, share_buffer,
+      gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::NORMAL, attrib_helper,
+      GURL::EmptyGURL(), base::ThreadTaskRunnerHandle::Get());
   if (!command_buffer_)
     return false;
 
   command_buffer_->SetGpuControlClient(this);
 
   if (shared_state_handle)
     *shared_state_handle = command_buffer_->GetSharedStateHandle();
   if (capabilities)
     *capabilities = command_buffer_->GetCapabilities();
   if (command_buffer_id)
@@ skipping 80 matching lines @@
   if (!mailboxes_to_reuse_.empty()) {
     gpu::Mailbox mailbox = mailboxes_to_reuse_.back();
     mailboxes_to_reuse_.pop_back();
     return mailbox;
   }
 
   return gpu::Mailbox::Generate();
 }
 
 }  // namespace content