Added EGL based GLContext....

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "app/gfx/gl/gl_context.h"
+#include "app/gfx/gl/gl_implementation.h"
 #include "base/callback.h"
 #include "base/scoped_ptr.h"
 #include "base/weak_ptr.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
@@ skipping 213 matching lines @@
  public:
   explicit FrameBuffer(GLES2DecoderImpl* decoder);
   ~FrameBuffer();
 
   // Create a new frame buffer.
   void Create();
 
   // Attach a color render buffer to a frame buffer.
   void AttachRenderTexture(Texture* texture);
 
-  // Attach a depth stencil render buffer to a frame buffer. Note that
-  // this unbinds any currently bound frame buffer.
-  void AttachDepthStencilRenderBuffer(RenderBuffer* render_buffer);
+  // Attach a render buffer to a frame buffer. Note that this unbinds any
+  // currently bound frame buffer.
+  void AttachRenderBuffer(GLenum target, RenderBuffer* render_buffer);
 
   // Clear the given attached buffers.
   void Clear(GLbitfield buffers);
 
   // Destroy the frame buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
   // See glCheckFramebufferStatusEXT.
   GLenum CheckStatus();
@@ skipping 857 matching lines @@
   ProgramManager::ProgramInfo::Ref current_program_;
 
   // The currently bound framebuffer
   FramebufferManager::FramebufferInfo::Ref bound_framebuffer_;
 
   // The currently bound renderbuffer
   RenderbufferManager::RenderbufferInfo::Ref bound_renderbuffer_;
 
   bool anti_aliased_;
 
-  // The offscreen frame buffer that the client renders to.
+  // The offscreen frame buffer that the client renders to. With EGL, the
+  // depth and stencil buffers are separate. With regular GL there is a single
+  // packed depth stencil buffer in offscreen_target_depth_render_buffer_.
+  // offscreen_target_stencil_render_buffer_ is unused.
   scoped_ptr<FrameBuffer> offscreen_target_frame_buffer_;
   scoped_ptr<Texture> offscreen_target_color_texture_;
-  scoped_ptr<RenderBuffer> offscreen_target_depth_stencil_render_buffer_;
+  scoped_ptr<RenderBuffer> offscreen_target_depth_render_buffer_;
+  scoped_ptr<RenderBuffer> offscreen_target_stencil_render_buffer_;
 
   // The copy that is saved when SwapBuffers is called.
   scoped_ptr<Texture> offscreen_saved_color_texture_;
 
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
 
   // The last error message set.
   std::string last_error_;
 
   bool use_shader_translator_;
@@ skipping 99 matching lines @@
 
 bool Texture::AllocateStorage(const gfx::Size& size) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedTexture2DBinder binder(decoder_, id_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(
       GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 
   glTexImage2D(GL_TEXTURE_2D,
                0,  // mip level
                GL_RGBA,
                size.width(),
                size.height(),
                0,  // border
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                NULL);
@@ skipping 83 matching lines @@
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   GLuint attach_id = texture ? texture->id() : 0;
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
                             GL_COLOR_ATTACHMENT0,
                             GL_TEXTURE_2D,
                             attach_id,
                             0);
 }
 
-void FrameBuffer::AttachDepthStencilRenderBuffer(RenderBuffer* render_buffer) {
+void FrameBuffer::AttachRenderBuffer(GLenum target,
+                                     RenderBuffer* render_buffer) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   GLuint attach_id = render_buffer ? render_buffer->id() : 0;
   glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
-                               GL_DEPTH_ATTACHMENT,
-                               GL_RENDERBUFFER,
-                               attach_id);
-  glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
-                               GL_STENCIL_ATTACHMENT,
+                               target,
                                GL_RENDERBUFFER,
                                attach_id);
 }
 
 void FrameBuffer::Clear(GLbitfield buffers) {
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   glClear(buffers);
 }
 
@@ skipping 27 matching lines @@
       attrib_0_size_(0),
       active_texture_unit_(0),
       black_2d_texture_id_(0),
       black_cube_texture_id_(0),
       anti_aliased_(false),
       use_shader_translator_(true) {
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
+
+  // The shader translator is not needed for EGL because it already uses the
+  // GLSL ES syntax. It is translated for the unit tests because
+  // GLES2DecoderWithShaderTest.GetShaderInfoLogValidArgs passes the empty
+  // string to CompileShader and this is not a valid shader. TODO(apatrick):
+  // fix this test.
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 ||
+      gfx::GetGLImplementation() == gfx::kGLImplementationMockGL) {
+    use_shader_translator_ = false;
+  }
 }
 
 bool GLES2DecoderImpl::Initialize(gfx::GLContext* context,
                                   const gfx::Size& size,
                                   GLES2Decoder* parent,
                                   uint32 parent_client_texture_id) {
   DCHECK(context);
   DCHECK(!context_);
   context_ = context;
 
   // Create a GL context that is kept in a default state and shares a namespace
   // with the main GL context.
-  default_context_.reset(gfx::GLContext::CreateOffscreenGLContext(
-      context_->GetHandle()));
+  default_context_.reset(gfx::GLContext::CreateOffscreenGLContext(context_));
   if (!default_context_.get()) {
     Destroy();
     return false;
   }
 
   // Keep only a weak pointer to the parent so we don't unmap its client
   // frame buffer after it has been destroyed.
   if (parent)
     parent_ = static_cast<GLES2DecoderImpl*>(parent)->AsWeakPtr();
 
@@ skipping 38 matching lines @@
                GL_UNSIGNED_BYTE, black);
   glBindTexture(GL_TEXTURE_2D, 0);
   glBindTexture(GL_TEXTURE_CUBE_MAP, black_cube_texture_id_);
   for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
     glTexImage2D(GLES2Util::IndexToGLFaceTarget(ii), 0, GL_RGBA, 1, 1, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, black);
   }
   glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
   CHECK_GL_ERROR();
 
-#if !defined(UNIT_TEST)
   if (context_->IsOffscreen()) {
     // Create the target frame buffer. This is the one that the client renders
     // directly to.
     offscreen_target_frame_buffer_.reset(new FrameBuffer(this));
     offscreen_target_frame_buffer_->Create();
     offscreen_target_color_texture_.reset(new Texture(this));
     offscreen_target_color_texture_->Create();
-    offscreen_target_depth_stencil_render_buffer_.reset(
+    offscreen_target_depth_render_buffer_.reset(
         new RenderBuffer(this));
-    offscreen_target_depth_stencil_render_buffer_->Create();
+    offscreen_target_depth_render_buffer_->Create();
+    offscreen_target_stencil_render_buffer_.reset(
+        new RenderBuffer(this));
+    offscreen_target_stencil_render_buffer_->Create();
 
     // Create the saved offscreen texture. The target frame buffer is copied
     // here when SwapBuffers is called.
     offscreen_saved_color_texture_.reset(new Texture(this));
     offscreen_saved_color_texture_->Create();
 
     // Map the ID of the saved offscreen texture into the parent so that
     // it can reference it.
     if (parent_) {
       GLuint service_id = offscreen_saved_color_texture_->id();
       TextureManager::TextureInfo* info =
           parent_->CreateTextureInfo(parent_client_texture_id, service_id);
       parent_->texture_manager()->SetInfoTarget(info, GL_TEXTURE_2D);
     }
 
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
     pending_offscreen_size_ = size;
     if (!UpdateOffscreenFrameBufferSize()) {
       DLOG(ERROR) << "Could not allocate offscreen buffer storage.";
       Destroy();
       return false;
     }
 
     // Bind to the new default frame buffer (the offscreen target frame buffer).
     // This should now be associated with ID zero.
     DoBindFramebuffer(GL_FRAMEBUFFER, 0);
   }
-#endif  // UNIT_TEST
 
-#if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
   // OpenGL ES 2.0 implicitly enables the desktop GL capability
   // VERTEX_PROGRAM_POINT_SIZE and doesn't expose this enum. This fact
   // isn't well documented; it was discovered in the Khronos OpenGL ES
   // mailing list archives.
-  glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
+    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
+  }
 
-#if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER) && !defined(UNIT_TEST)
+#if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
   // Initialize GLSL ES to GLSL translator.
-  if (!ShInitialize()) {
-    DLOG(ERROR) << "Could not initialize GLSL translator.";
-    Destroy();
-    return false;
+  static bool glsl_translator_initialized = false;
+  if (!glsl_translator_initialized) {
+    if (!ShInitialize()) {
+      DLOG(ERROR) << "Could not initialize GLSL translator.";
+      Destroy();
+      return false;
+    }
+    glsl_translator_initialized = true;
   }
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
-#endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 
   return true;
 }
 
 bool GLES2DecoderImpl::GenBuffersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetBufferInfo(client_ids[ii])) {
       return false;
     }
   }
@@ skipping 95 matching lines @@
       GLuint service_id = info->service_id();
       glDeleteTextures(1, &service_id);
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
-#if defined(UNIT_TEST)
-  return true;
-#else
   return context_->MakeCurrent();
-#endif
 }
 
 gfx::Size GLES2DecoderImpl::GetBoundFrameBufferSize() {
   if (bound_framebuffer_ != 0) {
     int width = 0;
     int height = 0;
 
     // Assume we have to have COLOR_ATTACHMENT0. Should we check for depth and
     // stencil.
     GLint fb_type = 0;
@@ skipping 58 matching lines @@
         }
       default:
         // unknown so assume width and height are zero.
         break;
     }
 
     return gfx::Size(width, height);
   } else if (offscreen_target_color_texture_.get()) {
     return offscreen_target_color_texture_->size();
   } else {
-#if defined(UNIT_TEST)
-    return gfx::Size(INT_MAX, INT_MAX);
-#else
     return context_->GetSize();
-#endif
   }
 }
 
 bool GLES2DecoderImpl::UpdateOffscreenFrameBufferSize() {
   if (offscreen_target_color_texture_->size() == pending_offscreen_size_)
     return true;
 
   if (parent_) {
     // Create the saved offscreen color texture (only accessible to parent).
     offscreen_saved_color_texture_->AllocateStorage(pending_offscreen_size_);
 
     // Attach the saved offscreen color texture to a frame buffer so we can
     // clear it with glClear.
     offscreen_target_frame_buffer_->AttachRenderTexture(
         offscreen_saved_color_texture_.get());
     if (offscreen_target_frame_buffer_->CheckStatus() !=
         GL_FRAMEBUFFER_COMPLETE) {
       return false;
     }
 
-#if !defined(UNIT_TEST)
+    // TODO(apatrick): Fix this once ANGLE supports shared contexts.
     // Clear the saved offscreen color texture. Use default GL context
     // to ensure clear is not affected by client set state.
-    {  // NOLINT
+    if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
       ScopedDefaultGLContext scoped_context(this);
-      glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
+      glBindFramebufferEXT(GL_FRAMEBUFFER,
                            offscreen_target_frame_buffer_->id());
       glClear(GL_COLOR_BUFFER_BIT);
-      glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+      glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
 
       if (glGetError() != GL_NO_ERROR)
         return false;
     }
-#endif
   }
 
   // Reallocate the offscreen target buffers.
   if (!offscreen_target_color_texture_->AllocateStorage(
       pending_offscreen_size_)) {
     return false;
   }
 
-  if (!offscreen_target_depth_stencil_render_buffer_->AllocateStorage(
-      pending_offscreen_size_, GL_DEPTH24_STENCIL8)) {
-    return false;
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
+    // ANGLE only allows 16-bit depth buffers to be requested. As it happens,
+    // it creates a 24-bit depth buffer behind the scenes.
+    // TODO(apatrick): Attempt to use a packed 24/8 depth stencil buffer here if
+    // the extension is available.
+    if (!offscreen_target_depth_render_buffer_->AllocateStorage(
+        pending_offscreen_size_, GL_DEPTH_COMPONENT16)) {
+      return false;
+    }
+
+    if (!offscreen_target_stencil_render_buffer_->AllocateStorage(
+        pending_offscreen_size_, GL_STENCIL_INDEX8)) {
+      return false;
+    }
+  } else {
+    if (!offscreen_target_depth_render_buffer_->AllocateStorage(
+        pending_offscreen_size_, GL_DEPTH24_STENCIL8)) {
+      return false;
+    }
   }
 
   // Attach the offscreen target buffers to the target frame buffer.
   offscreen_target_frame_buffer_->AttachRenderTexture(
       offscreen_target_color_texture_.get());
-  offscreen_target_frame_buffer_->AttachDepthStencilRenderBuffer(
-      offscreen_target_depth_stencil_render_buffer_.get());
+  offscreen_target_frame_buffer_->AttachRenderBuffer(
+      GL_DEPTH_ATTACHMENT,
+      offscreen_target_depth_render_buffer_.get());
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
+    offscreen_target_frame_buffer_->AttachRenderBuffer(
+        GL_STENCIL_ATTACHMENT,
+        offscreen_target_stencil_render_buffer_.get());
+  } else {
+    offscreen_target_frame_buffer_->AttachRenderBuffer(
+        GL_STENCIL_ATTACHMENT,
+        offscreen_target_depth_render_buffer_.get());
+  }
   if (offscreen_target_frame_buffer_->CheckStatus() !=
       GL_FRAMEBUFFER_COMPLETE) {
     return false;
   }
 
-#if !defined(UNIT_TEST)
+  // TODO(apatrick): Fix this once ANGLE supports shared contexts.
   // Clear offscreen frame buffer to its initial state. Use default GL context
   // to ensure clear is not affected by client set state.
-  {  // NOLINT
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     ScopedDefaultGLContext scoped_context(this);
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
+    glBindFramebufferEXT(GL_FRAMEBUFFER,
                          offscreen_target_frame_buffer_->id());
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
 
     if (glGetError() != GL_NO_ERROR)
       return false;
   }
-#endif
 
   if (parent_) {
     // Create the saved offscreen color texture (only accessible to parent).
     offscreen_saved_color_texture_->AllocateStorage(pending_offscreen_size_);
 
     // Update the info about the offscreen saved color texture in the parent.
     // The reference to the parent is a weak pointer and will become null if the
     // parent is later destroyed.
     GLuint service_id = offscreen_saved_color_texture_->id();
 
@@ skipping 51 matching lines @@
     if (offscreen_target_frame_buffer_.get()) {
       offscreen_target_frame_buffer_->Destroy();
       offscreen_target_frame_buffer_.reset();
     }
 
     if (offscreen_target_color_texture_.get()) {
       offscreen_target_color_texture_->Destroy();
       offscreen_target_color_texture_.reset();
     }
 
-    if (offscreen_target_depth_stencil_render_buffer_.get()) {
-      offscreen_target_depth_stencil_render_buffer_->Destroy();
-      offscreen_target_depth_stencil_render_buffer_.reset();
+    if (offscreen_target_depth_render_buffer_.get()) {
+      offscreen_target_depth_render_buffer_->Destroy();
+      offscreen_target_depth_render_buffer_.reset();
+    }
+
+    if (offscreen_target_stencil_render_buffer_.get()) {
+      offscreen_target_stencil_render_buffer_->Destroy();
+      offscreen_target_stencil_render_buffer_.reset();
     }
 
     if (offscreen_saved_color_texture_.get()) {
       offscreen_saved_color_texture_->Destroy();
       offscreen_saved_color_texture_.reset();
     }
   }
 
   if (default_context_.get()) {
     default_context_->Destroy();
     default_context_.reset();
   }
-
-#if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2) && !defined(UNIT_TEST)
-#if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
-  // Terminate GLSL translator.
-  ShFinalize();
-#endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
-#endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 }
 
 void GLES2DecoderImpl::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
   // We can't resize the render buffers immediately because there might be a
   // partial frame rendered into them and we don't want the tail end of that
   // rendered into the reallocated storage. Defer until the next SwapBuffers.
   pending_offscreen_size_ = size;
 }
 
 const char* GLES2DecoderImpl::GetCommandName(unsigned int command_id) const {
@@ skipping 249 matching lines @@
     SetGLError(GL_INVALID_OPERATION,
                "glGenerateMipmaps: Can not generate mips for npot textures");
     return;
   }
   glGenerateMipmapEXT(target);
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
-  switch (pname) {
-#if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
+    switch (pname) {
     case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
       *num_written = 1;
       if (params) {
         *params = GL_RGBA;  // TODO(gman): get correct format.
       }
       return true;
     case GL_IMPLEMENTATION_COLOR_READ_TYPE:
       *num_written = 1;
       if (params) {
         *params = GL_UNSIGNED_BYTE;  // TODO(gman): get correct type.
@@ skipping 10 matching lines @@
       if (params) {
         *params = group_->max_varying_vectors();
       }
       return true;
     case GL_MAX_VERTEX_UNIFORM_VECTORS:
       *num_written = 1;
       if (params) {
         *params = group_->max_vertex_uniform_vectors();
       }
       return true;
-#endif
+    }
+  }
+  switch (pname) {
     case GL_COMPRESSED_TEXTURE_FORMATS:
       *num_written = 0;
       // We don't support compressed textures.
       return true;
     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
       *num_written = 1;
       if (params) {
         *params = 0;  // We don't support compressed textures.
       }
       return true;
@@ skipping 1003 matching lines @@
 
 void GLES2DecoderImpl::DoCompileShader(GLuint client_id) {
   ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
       client_id, "glCompileShader");
   if (!info) {
     return;
   }
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
   const char* shader_src = info->source().c_str();
-#if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2) && !defined(UNIT_TEST)
 #if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
   ShHandle compiler = 0;
   if (use_shader_translator_) {
     int dbg_options = 0;
     EShLanguage language = info->shader_type() == GL_VERTEX_SHADER ?
         EShLangVertex : EShLangFragment;
     TBuiltInResource resources;
     resources.maxVertexAttribs = group_->max_vertex_attribs();
     resources.maxVertexUniformVectors =
         group_->max_vertex_uniform_vectors();
     resources.maxVaryingVectors = group_->max_varying_vectors();
     resources.maxVertexTextureImageUnits =
         group_->max_vertex_texture_image_units();
     resources.maxCombinedTextureImageUnits = group_->max_texture_units();
     resources.maxTextureImageUnits = group_->max_texture_image_units();
     resources.maxFragmentUniformVectors =
         group_->max_fragment_uniform_vectors();
     resources.maxDrawBuffers = 1;
     compiler = ShConstructCompiler(language, dbg_options);
     if (!ShCompile(compiler, &shader_src, 1, EShOptNone, &resources,
                    dbg_options)) {
       info->SetTranslationStatus(false, ShGetInfoLog(compiler));
       ShDestruct(compiler);
       return;
     }
+
     info->SetTranslationStatus(true, "");
     shader_src = ShGetObjectCode(compiler);
   }
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
-#endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 
   glShaderSource(info->service_id(), 1, &shader_src, NULL);
   glCompileShader(info->service_id());
-#if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2) && !defined(UNIT_TEST)
 #ifdef GLES2_GPU_SERVICE_TRANSLATE_SHADER
   if (use_shader_translator_) {
     ShDestruct(compiler);
   }
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
-#endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 };
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader, GLenum pname, GLint* params) {
   ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
       shader, "glGetShaderiv");
   if (!info) {
     return;
   }
   switch (pname) {
@@ skipping 716 matching lines @@
     default:
       str = gl_str;
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferData(
-  GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {
+    GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {
   if (!ValidateGLenumBufferTarget(target)) {
     SetGLError(GL_INVALID_ENUM, "glBufferData: target GL_INVALID_ENUM");
     return;
   }
   if (!ValidateGLenumBufferUsage(usage)) {
     SetGLError(GL_INVALID_ENUM, "glBufferData: usage GL_INVALID_ENUM");
     return;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData: size < 0");
@@ skipping 644 matching lines @@
 
     // First check to see if a deferred offscreen render buffer resize is
     // pending.
     if (!UpdateOffscreenFrameBufferSize())
       return error::kLostContext;
 
     ScopedFrameBufferBinder binder(this, offscreen_target_frame_buffer_->id());
     offscreen_saved_color_texture_->Copy(
         offscreen_saved_color_texture_->size());
   } else {
-#if !defined(UNIT_TEST)
     context_->SwapBuffers();
-#endif
   }
 
   // TODO(kbr): when the back buffer is multisampled, then at least on Mac
   // OS X (and probably on all platforms, for best semantics), we will need
   // to perform the resolve step and bind the offscreen_saved_color_texture_
   // as the color attachment before calling the swap buffers callback, which
   // expects a normal (non-multisampled) frame buffer for glCopyTexImage2D /
   // glReadPixels. After the callback runs, the multisampled frame buffer
   // needs to be bound again.
 
@@ skipping 35 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu