pepper: parse context creation attrib list on the plugin side

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 48 matching lines @@
   // Unset the client before the command_buffer_ is destroyed, similar to how
   // WeakPtrFactory invalidates before it.
   if (command_buffer_)
     command_buffer_->SetGpuControlClient(nullptr);
 }
 
 // static
 PP_Resource PPB_Graphics3D_Impl::CreateRaw(
     PP_Instance instance,
     PP_Resource share_context,
-    const int32_t* attrib_list,
+    const gpu::gles2::ContextCreationAttribHelper& attrib_helper,
     gpu::Capabilities* capabilities,
     base::SharedMemoryHandle* shared_state_handle,
     gpu::CommandBufferId* command_buffer_id) {
   PPB_Graphics3D_API* share_api = NULL;
   if (share_context) {
     EnterResourceNoLock<PPB_Graphics3D_API> enter(share_context, true);
     if (enter.failed())
       return 0;
     share_api = enter.object();
   }
   scoped_refptr<PPB_Graphics3D_Impl> graphics_3d(
       new PPB_Graphics3D_Impl(instance));
-  if (!graphics_3d->InitRaw(share_api, attrib_list, capabilities,
+  if (!graphics_3d->InitRaw(share_api, attrib_helper, capabilities,
                             shared_state_handle, command_buffer_id))
     return 0;
   return graphics_3d->GetReference();
 }
 
 PP_Bool PPB_Graphics3D_Impl::SetGetBuffer(int32_t transfer_buffer_id) {
   GetCommandBuffer()->SetGetBuffer(transfer_buffer_id);
   return PP_TRUE;
 }
 
@@ skipping 109 matching lines @@
   } else {
     // Wait for the command to complete on the GPU to allow for throttling.
     command_buffer_->SignalSyncToken(
         sync_token, base::Bind(&PPB_Graphics3D_Impl::OnSwapBuffers,
                                weak_ptr_factory_.GetWeakPtr()));
   }
 
   return PP_OK_COMPLETIONPENDING;
 }
 
-bool PPB_Graphics3D_Impl::InitRaw(PPB_Graphics3D_API* share_context,
-                                  const int32_t* attrib_list,
-                                  gpu::Capabilities* capabilities,
-                                  base::SharedMemoryHandle* shared_state_handle,
-                                  gpu::CommandBufferId* command_buffer_id) {
+bool PPB_Graphics3D_Impl::InitRaw(
+    PPB_Graphics3D_API* share_context,
+    const gpu::gles2::ContextCreationAttribHelper& requested_attribs,
+    gpu::Capabilities* capabilities,
+    base::SharedMemoryHandle* shared_state_handle,
+    gpu::CommandBufferId* command_buffer_id) {
   PepperPluginInstanceImpl* plugin_instance =
       HostGlobals::Get()->GetInstance(pp_instance());
   if (!plugin_instance)
     return false;
 
   RenderView* render_view = plugin_instance->GetRenderView();
   if (!render_view)
     return false;
 
   const WebPreferences& prefs = render_view->GetWebkitPreferences();
@@ skipping 10 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;
 
-  gpu::gles2::ContextCreationAttribHelper attrib_helper;
-  std::vector<int32_t> attribs;
-  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:
-          attrib_helper.offscreen_framebuffer_size.set_width(attr[1]);
-          break;
-        case PP_GRAPHICS3DATTRIB_HEIGHT:
-          attrib_helper.offscreen_framebuffer_size.set_height(attr[1]);
-          break;
-        case PP_GRAPHICS3DATTRIB_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);
-  }
-  if (!attrib_helper.Parse(attribs))
-    return false;
+  has_alpha_ = requested_attribs.alpha_size > 0;
+
+  gpu::gles2::ContextCreationAttribHelper attrib_helper = requested_attribs;
   attrib_helper.should_use_native_gmb_for_backbuffer = use_image_chromium_;
 
   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(
@@ skipping 95 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