gpu: Refactor GpuMemoryBuffer framework for multi-process support.

gpu/command_buffer/tests/gl_manager.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/command_buffer/tests/gl_manager.h"
 
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "gpu/command_buffer/service/gpu_control_service.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 
 namespace gpu {
 
 int GLManager::use_count_;
 scoped_refptr<gfx::GLShareGroup>* GLManager::base_share_group_;
 scoped_refptr<gfx::GLSurface>* GLManager::base_surface_;
 scoped_refptr<gfx::GLContext>* GLManager::base_context_;
 
 GLManager::Options::Options()
     : size(4, 4),
       share_group_manager(NULL),
       share_mailbox_manager(NULL),
       virtual_manager(NULL),
       bind_generates_resource(false),
       context_lost_allowed(false),
-      image_manager(NULL),
-      image_factory(NULL) {
+      image_manager(NULL) {
 }
 
 GLManager::GLManager()
     : context_lost_allowed_(false) {
   SetupBaseContext();
 }
 
 GLManager::~GLManager() {
   --use_count_;
   if (!use_count_) {
@@ skipping 41 matching lines @@
     client_share_group =
       options.share_group_manager->gles2_implementation()->share_group();
   }
 
   gfx::GLContext* real_gl_context = NULL;
   if (options.virtual_manager) {
     real_gl_context = options.virtual_manager->context();
   }
 
   // From <EGL/egl.h>.
+#ifndef EGL_ALPHA_SIZE

[piman, 2013/08/14 20:43:26]

Why is this needed suddenly?

[reveman, 2013/08/15 15:00:54]

this file now has to include gpu_control_service.h, which has to include
ui/gfx/gpu_memory_buffer.h for the definition of gfx::GpuMemoryBufferHandle,
which contains a EGLClientBuffer on android and that makes us pull in egl.h.
Result is of course that these enums are already defined.

DEPS doesn't allow egl.h to be included here directly, which I think makes
sense.

Created https://codereview.chromium.org/23244002/ that limits the need to define
these EGL constants to command_buffer/common/gles2_cmd_helper.cc. These
constants are no longer needed here after rebasing this patch on that cl.

   const int32 EGL_ALPHA_SIZE = 0x3021;
+#endif
+#ifndef EGL_BLUE_SIZE
   const int32 EGL_BLUE_SIZE = 0x3022;
+#endif
+#ifndef EGL_GREEN_SIZE
   const int32 EGL_GREEN_SIZE = 0x3023;
+#endif
+#ifndef EGL_RED_SIZE
   const int32 EGL_RED_SIZE = 0x3024;
+#endif
+#ifndef EGL_DEPTH_SIZE
   const int32 EGL_DEPTH_SIZE = 0x3025;
+#endif
+#ifndef EGL_NONE
   const int32 EGL_NONE = 0x3038;
+#endif
 
   mailbox_manager_ =
       mailbox_manager ? mailbox_manager : new gles2::MailboxManager;
   share_group_ =
       share_group ? share_group : new gfx::GLShareGroup;
 
   gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
   const char* allowed_extensions = "*";
   std::vector<int32> attribs;
   attribs.push_back(EGL_RED_SIZE);
@@ skipping 16 matching lines @@
                                             options.bind_generates_resource);
   }
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group));
 
   command_buffer_.reset(new CommandBufferService(
       decoder_->GetContextGroup()->transfer_buffer_manager()));
   ASSERT_TRUE(command_buffer_->Initialize())
       << "could not create command buffer service";
 
+  gpu_control_.reset(
+      new GpuControlService(decoder_->GetContextGroup()->image_manager(),
+                            options.gpu_memory_buffer_factory));
+
   gpu_scheduler_.reset(new GpuScheduler(command_buffer_.get(),
                                         decoder_.get(),
                                         decoder_.get()));
 
   decoder_->set_engine(gpu_scheduler_.get());
 
   surface_ = gfx::GLSurface::CreateOffscreenGLSurface(options.size);
   ASSERT_TRUE(surface_.get() != NULL) << "could not create offscreen surface";
 
   if (real_gl_context) {
@@ skipping 37 matching lines @@
 
   // Create a transfer buffer.
   transfer_buffer_.reset(new TransferBuffer(gles2_helper_.get()));
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_.reset(new gles2::GLES2Implementation(
       gles2_helper_.get(),
       client_share_group,
       transfer_buffer_.get(),
       options.bind_generates_resource,
-      options.image_factory));
+      gpu_control_.get()));
 
   ASSERT_TRUE(gles2_implementation_->Initialize(
       kStartTransferBufferSize,
       kMinTransferBufferSize,
       kMaxTransferBufferSize)) << "Could not init GLES2Implementation";
 
   MakeCurrent();
 }
 
 void GLManager::SetupBaseContext() {
@@ skipping 50 matching lines @@
   if (!context_lost_allowed_) {
     ASSERT_EQ(::gpu::error::kNoError, state.error);
   }
 }
 
 bool GLManager::GetBufferChanged(int32 transfer_buffer_id) {
   return gpu_scheduler_->SetGetBuffer(transfer_buffer_id);
 }
 
 }  // namespace gpu