Pass initial size and GPU preference via context attributes

gpu/ipc/service/gpu_command_buffer_stub.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/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 458 matching lines @@
         manager->shader_translator_cache(),
         manager->framebuffer_completeness_cache(), feature_info,
         init_params.attribs.bind_generates_resource,
         gmb_factory ? gmb_factory->AsImageFactory() : nullptr);
   }
 
 #if defined(OS_MACOSX)
   // Virtualize PreferIntegratedGpu contexts by default on OS X to prevent
   // performance regressions when enabling FCM.
   // http://crbug.com/180463
-  if (init_params.gpu_preference == gl::PreferIntegratedGpu)
+  if (init_params.attribs.gpu_preference == gl::PreferIntegratedGpu)
     use_virtualized_gl_context_ = true;
 #endif
 
   use_virtualized_gl_context_ |=
       context_group_->feature_info()->workarounds().use_virtualized_gl_contexts;
 
   // MailboxManagerSync synchronization correctness currently depends on having
   // only a single context. See crbug.com/510243 for details.
   use_virtualized_gl_context_ |= channel_->mailbox_manager()->UsesSync();
 
   gl::GLSurface::Format surface_format = gl::GLSurface::SURFACE_DEFAULT;
   bool offscreen = (surface_handle_ == kNullSurfaceHandle);
   gl::GLSurface* default_surface = manager->GetDefaultOffscreenSurface();
   if (!default_surface) {
     DLOG(ERROR) << "Failed to create default offscreen surface.";
     return false;
   }
 #if defined(OS_ANDROID)
   if (init_params.attribs.red_size <= 5 &&
       init_params.attribs.green_size <= 6 &&
       init_params.attribs.blue_size <= 5 &&
       init_params.attribs.alpha_size == 0)
     surface_format = gl::GLSurface::SURFACE_RGB565;
   // We can only use virtualized contexts for onscreen command buffers if their
   // config is compatible with the offscreen ones - otherwise MakeCurrent fails.
   if (surface_format != default_surface->GetFormat() && !offscreen)
     use_virtualized_gl_context_ = false;
 #endif
 
-  gfx::Size initial_size = init_params.size;
-  if (offscreen && initial_size.IsEmpty()) {
-    // If we're an offscreen surface with zero width and/or height, set to a
-    // non-zero size so that we have a complete framebuffer for operations like
-    // glClear.
-    initial_size = gfx::Size(1, 1);
-  }
-
   command_buffer_.reset(new CommandBufferService(
       context_group_->transfer_buffer_manager()));
 
   decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                       decoder_.get()));
   sync_point_client_ = channel_->sync_point_manager()->CreateSyncPointClient(
       channel_->GetSyncPointOrderData(stream_id_),
       CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
@@ skipping 12 matching lines @@
       return false;
     }
   }
 
   scoped_refptr<gl::GLContext> context;
   gl::GLShareGroup* gl_share_group = channel_->share_group();
   if (use_virtualized_gl_context_ && gl_share_group) {
     context = gl_share_group->GetSharedContext();
     if (!context.get()) {
       context = gl::init::CreateGLContext(gl_share_group, default_surface,
-                                          init_params.gpu_preference);
+                                          init_params.attribs.gpu_preference);
       if (!context.get()) {
         DLOG(ERROR) << "Failed to create shared context for virtualization.";
         return false;
       }
       // Ensure that context creation did not lose track of the intended
       // gl_share_group.
       DCHECK(context->share_group() == gl_share_group);
       gl_share_group->SetSharedContext(context.get());
     }
     // This should be either:
     // (1) a non-virtual GL context, or
     // (2) a mock context.
     DCHECK(context->GetHandle() ||
            gl::GetGLImplementation() == gl::kGLImplementationMockGL);
     context = new GLContextVirtual(
         gl_share_group, context.get(), decoder_->AsWeakPtr());
-    if (!context->Initialize(surface_.get(), init_params.gpu_preference)) {
+    if (!context->Initialize(surface_.get(),
+                             init_params.attribs.gpu_preference)) {
       // The real context created above for the default offscreen surface
       // might not be compatible with this surface.
       context = NULL;
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       return false;
     }
   }
   if (!context.get()) {
     context = gl::init::CreateGLContext(gl_share_group, surface_.get(),
-                                        init_params.gpu_preference);
+                                        init_params.attribs.gpu_preference);
   }
   if (!context.get()) {
     DLOG(ERROR) << "Failed to create context.";
     return false;
   }
 
   if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
     return false;
   }
 
   if (!context->GetGLStateRestorer()) {
     context->SetGLStateRestorer(
         new GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
   if (!context_group_->has_program_cache() &&
       !context_group_->feature_info()->workarounds().disable_program_cache) {
     context_group_->set_program_cache(manager->program_cache());
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
-  if (!decoder_->Initialize(surface_, context, offscreen, initial_size,
+  if (!decoder_->Initialize(surface_, context, offscreen,
                             gpu::gles2::DisallowedFeatures(),
                             init_params.attribs)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
     return false;
   }
 
   if (manager->gpu_preferences().enable_gpu_service_logging) {
     decoder_->set_log_commands(true);
   }
 
@@ skipping 510 matching lines @@
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, params));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace gpu