Update the native_viewport interface to allow specification of the surface configuration, currently…

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 <queue>
 #include <set>
 #include <utility>
 
@@ skipping 325 matching lines @@
 bool InProcessCommandBuffer::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback,
     InProcessCommandBuffer* share_group,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    ImageFactory* image_factory) {
+    ImageFactory* image_factory,
+    gfx::SurfaceConfiguration requested_configuration) {

[abarth-chromium, 2015/06/09 00:30:21]

gfx::SurfaceConfiguration -> const gfx::SurfaceConfiguration&

[iansf, 2015/06/09 01:52:04]

Done.

   DCHECK(!share_group || service_.get() == share_group->service_.get());
   context_lost_callback_ = WrapCallback(context_lost_callback);
 
   if (surface.get()) {
     // GPU thread must be the same as client thread due to GLSurface not being
     // thread safe.
     sequence_checker_.reset(new base::SequenceChecker);
     surface_ = surface;
   }
 
   gpu::Capabilities capabilities;
   InitializeOnGpuThreadParams params(is_offscreen,
                                      window,
                                      size,
                                      attribs,
                                      gpu_preference,
                                      &capabilities,
                                      share_group,
-                                     image_factory);
+                                     image_factory,
+                                     requested_configuration);
 
   base::Callback<bool(void)> init_task =
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
                  base::Unretained(this),
                  params);
 
   base::WaitableEvent completion(true, false);
   bool result = false;
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
@@ skipping 56 matching lines @@
   gpu_scheduler_.reset(
       new GpuScheduler(command_buffer.get(), decoder_.get(), decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
   command_buffer_ = command_buffer.Pass();
 
   decoder_->set_engine(gpu_scheduler_.get());
 
   if (!surface_.get()) {
     if (params.is_offscreen)
-      surface_ = gfx::GLSurface::CreateOffscreenGLSurface(params.size);
+      surface_ = gfx::GLSurface::CreateOffscreenGLSurface(
+          params.size, params.requested_configuration);
     else
-      surface_ = gfx::GLSurface::CreateViewGLSurface(params.window);
+      surface_ = gfx::GLSurface::CreateViewGLSurface(
+          params.window, params.requested_configuration);
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
   if (service_->UseVirtualizedGLContexts() ||
       decoder_->GetContextGroup()
@@ skipping 506 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu