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 222 matching lines @@
       *requires_sync_point = true;
       return source_handle;
     default:
       NOTREACHED();
       return gfx::GpuMemoryBufferHandle();
   }
 }
 
 }  // anonyous namespace
 
+
+InProcessCommandBuffer::
+  InitializeOnGpuThreadParams::InitializeOnGpuThreadParams(
+      bool is_offscreen,
+      gfx::AcceleratedWidget window,
+      const gfx::Size& size,
+      const std::vector<int32>& attribs,
+      gfx::GpuPreference gpu_preference,
+      gpu::Capabilities* capabilities,
+      InProcessCommandBuffer* share_group,
+      ImageFactory* image_factory,
+      const gfx::SurfaceConfiguration& requested_configuration)
+        : is_offscreen(is_offscreen),
+          window(window),
+          size(size),
+          attribs(attribs),
+          gpu_preference(gpu_preference),
+          capabilities(capabilities),
+          context_group(share_group),
+          image_factory(image_factory),
+          requested_configuration(requested_configuration) {
+}
+
+
 InProcessCommandBuffer::Service::Service() {}
 
 InProcessCommandBuffer::Service::~Service() {}
 
 scoped_refptr<gfx::GLShareGroup>
 InProcessCommandBuffer::Service::share_group() {
   if (!share_group_.get())
     share_group_ = new gfx::GLShareGroup;
   return share_group_;
 }
@@ skipping 83 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,
+    const gfx::SurfaceConfiguration& requested_configuration) {
   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