/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "gles/gles_context.h"

#include <GLES/gl.h>
#include <GLES/glext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <algorithm>
#include <stdio.h>
#include <vector>

#include "common/alog.h"
#include "common/dlog.h"
#include "gles/gles_options.h"
#include "gles/debug.h"
#include "gles/framebuffer_data.h"
#include "gles/gles_utils.h"
#include "gles/macros.h"
#include "gles/program_data.h"
#include "gles/renderbuffer_data.h"
#include "gles/shader_data.h"
#include "gles/state.h"
#include "gles/texture_data.h"

namespace {

#define VERTEX_ATTRIBUTE_KEY(enum, name) name,
const char* kVertexAttributeNames[] = {VERTEX_ATTRIBUTE_KEY_TUPLE};
#undef VERTEX_ATTRIBUTE_KEY

uint32_t Hash(const char* str) {
  uint32_t res = 0;
  while (*str) {
    res = (res * 101)  +  *str++;
  }
  return res;
}

void DeleteShader(GLuint* shader) {
  if (GetCurrentGlesContext()) {
    PASS_THROUGH(GetCurrentGlesContext(), DeleteShader, *shader);
  }
}

void DeleteProgram(ProgramContext* program) {
  if (GetCurrentGlesContext()) {
    program->Delete();
  }
}

}  // namespace

GlesContext::GlesContext(int32_t id, GlesVersion version, GlesContext* share,
                         void* underlying_context,
                         const UnderlyingApis* underlying_apis)
    : uniform_context_(this),
      texture_context_(this),
      pointer_context_(this),
      array_buffer_binding_(0),
      element_buffer_binding_(0),
      framebuffer_binding_(0),
      renderbuffer_binding_(0),
      version_(version),
      id_(id + version * 100000),
      initialized_(false),
      initialized_viewport_(false),
      error_(GL_NO_ERROR),
      gles_impl_(underlying_context),
      apis_(underlying_apis),
      share_group_(NULL),
      global_override_framebuffer_(0),
      global_framebuffer_(0),
      global_depth_renderbuffer_(0),
      global_stencil_renderbuffer_(0),
      cached_draw_width_(0),
      cached_draw_height_(0),
      cached_draw_stencil_size_(0),
      cached_draw_depth_size_(0),
      cached_global_texture_(0),
      vertex_shader_cache_(kCacheLimit, &DeleteShader),
      fragment_shader_cache_(kCacheLimit, &DeleteShader),
      program_cache_(kCacheLimit, &DeleteProgram),
      fullscreen_quad_(NULL),
      checks_enabled_(emugl::GlesOptions::GLErrorChecksEnabled()),
      global_extensions_(NULL),
      supports_packed_depth_stencil_(false) {
  if (share) {
    share_group_ = share->GetShareGroup();
  } else {
    share_group_ = ShareGroupPtr(new ShareGroup(this));
  }
}

GlesContext::~GlesContext() {
  DeleteFramebufferOverride();
  delete fullscreen_quad_;
}

void GlesContext::OnMakeCurrent() {
    Restore();
}

void GlesContext::Invalidate() {
  if (initialized_) {
    pointer_context_.Release();
    initialized_ = false;
  }
}

void GlesContext::Restore() {
  if (initialized_) {
      DLOG("Context already initialized, go away.");
    return;
  }

  const int max_texture_units = UniformContext::kMaxTextureUnits;
  DLOG("Initialize pointer, texture, and uniform contexts.");
  if (version_ == kGles11) {
    pointer_context_.Init(kNumVertexAttributeKeys);
  } else if (version_ == kGles20) {
    pointer_context_.Init(max_vertex_attribs_.Get());
  } else {
    LOG_ALWAYS_FATAL("Unknown GLES version %d", version_);
  }
  texture_context_.Init(max_texture_units, max_texture_size_.Get());
  uniform_context_.Init(max_texture_units);

  if (version_ == kGles11) {
      GLfloat values[4];
      DLOG("Pass through glVertexAttrib4fv");
      PASS_THROUGH(this, VertexAttrib4fv, kColorVertexAttribute,
              uniform_context_.GetColor().GetFloatArray(values));
      PASS_THROUGH(this, VertexAttrib4fv, kNormalVertexAttribute,
              uniform_context_.GetNormal().GetFloatArray(values));
      PASS_THROUGH(this, VertexAttrib1f, kPointSizeVertexAttribute,
              uniform_context_.GetPointParameters().current_size);
  }

  initialized_ = true;
}

void GlesContext::OnAttachSurface(SurfaceControlCallbackPtr sfc,
                                  GLint width, GLint height) {
  surface_callback_ = sfc;
  if (!initialized_viewport_) {
    initialized_viewport_ = true;

    // The first time that a context is attached to a surface, the context needs
    // to be initialized with the dimensions of the draw surface. These
    // dimensions are used to initialized the viewport and scissor rectangles
    // correctly for the surface.
    // It is the client's responsibility to maintain those values afterwards.
    viewport_.Mutate()[0] = 0;
    viewport_.Mutate()[1] = 0;
    viewport_.Mutate()[2] = width;
    viewport_.Mutate()[3] = height;
    PASS_THROUGH(this, Viewport, 0, 0, width, height);
    PASS_THROUGH(this, Scissor, 0, 0, width, height);
  }
}

void GlesContext::UpdateFramebufferOverride(GLint width, GLint height,
                                            GLint depth_size,
                                            GLint stencil_size,
                                            GLuint global_texture_name) {
  EnsureUnderlyingExtensionsKnown();

  const bool width_changed = cached_draw_width_ != width;
  const bool height_changed = cached_draw_height_ != height;
  const bool depth_changed = cached_draw_depth_size_ != depth_size;
  const bool stencil_changed = cached_draw_stencil_size_ != stencil_size;
  const bool texture_changed = cached_global_texture_ != global_texture_name;

  if (global_texture_name) {
    if (width_changed || height_changed || depth_changed || stencil_changed) {
      DeleteFramebufferOverride();
      PASS_THROUGH(this, GenFramebuffers, 1, &global_framebuffer_);
    }

    if (width_changed || height_changed || texture_changed) {
      SetupColorTextureAttachment(global_texture_name);
    }

    if (width_changed || height_changed || depth_changed || stencil_changed) {
      SetupDepthStencilAttachment(width, height, depth_size, stencil_size);
    }

    if (AreChecksEnabled()) {
      const GLint status = PASS_THROUGH(this, CheckFramebufferStatus,
                                        GL_FRAMEBUFFER);
      LOG_ALWAYS_FATAL_IF(status != GL_FRAMEBUFFER_COMPLETE,
                          "Error overriding framebuffer: 0x%x", status);
    }
    global_override_framebuffer_ = global_framebuffer_;
  } else {
    global_override_framebuffer_ = 0;
  }

  cached_draw_width_ = width;
  cached_draw_height_ = height;
  cached_draw_depth_size_ = depth_size;
  cached_draw_stencil_size_ = stencil_size;
  cached_global_texture_ = global_texture_name;

  // Restore original bindings as they may have been overridden when updating
  // the framebuffer attachments.
  PASS_THROUGH(this, BindRenderbuffer, GL_RENDERBUFFER,
               share_group_->GetRenderbufferGlobalName(renderbuffer_binding_));
  if (framebuffer_binding_ != 0) {
    PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER,
                 share_group_->GetFramebufferGlobalName(framebuffer_binding_));
  } else {
    PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER,
                 global_override_framebuffer_);
  }
}

void GlesContext::SetupColorTextureAttachment(GLuint texture) {
  PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER, global_framebuffer_);
  PASS_THROUGH(this, FramebufferTexture2D, GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
               GL_TEXTURE_2D, texture, 0);
}

void GlesContext::SetupDepthStencilAttachment(GLint width, GLint height,
                                              GLint depth_size,
                                              GLint stencil_size) {
  if (supports_packed_depth_stencil_ && depth_size && stencil_size) {
    LOG_ALWAYS_FATAL_IF(depth_size > 24 || depth_size < 0);
    LOG_ALWAYS_FATAL_IF(stencil_size > 8 || stencil_size < 0);

    // Both the depth and stencil buffer actually refer to the same object.
    PASS_THROUGH(this, GenRenderbuffers, 1, &global_depth_renderbuffer_);
    global_stencil_renderbuffer_ = global_depth_renderbuffer_;

    PASS_THROUGH(this, BindRenderbuffer, GL_RENDERBUFFER,
                 global_depth_renderbuffer_);
    PASS_THROUGH(this, RenderbufferStorage, GL_RENDERBUFFER,
                 GL_DEPTH24_STENCIL8_OES, width, height);
  } else {
    if (depth_size) {
      LOG_ALWAYS_FATAL_IF(depth_size > 16 || depth_size < 0);

      PASS_THROUGH(this, GenRenderbuffers, 1, &global_depth_renderbuffer_);
      PASS_THROUGH(this, BindRenderbuffer, GL_RENDERBUFFER,
                   global_depth_renderbuffer_);
      PASS_THROUGH(this, RenderbufferStorage, GL_RENDERBUFFER,
                   GL_DEPTH_COMPONENT16, width, height);
    }
    if (stencil_size) {
      LOG_ALWAYS_FATAL_IF(stencil_size > 8 || stencil_size < 0);

      PASS_THROUGH(this, GenRenderbuffers, 1,
                   &global_stencil_renderbuffer_);
      PASS_THROUGH(this, BindRenderbuffer, GL_RENDERBUFFER,
                   global_stencil_renderbuffer_);
      PASS_THROUGH(this, RenderbufferStorage, GL_RENDERBUFFER,
                   GL_STENCIL_INDEX8, width, height);
    }
  }

  PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER, global_framebuffer_);
  PASS_THROUGH(this, FramebufferRenderbuffer, GL_FRAMEBUFFER,
               GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
               global_depth_renderbuffer_);
  PASS_THROUGH(this, FramebufferRenderbuffer, GL_FRAMEBUFFER,
               GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
               global_stencil_renderbuffer_);
}

void GlesContext::DeleteFramebufferOverride() {
  // Note that it is safe to delete the same renderbuffer object multiple
  // times. The GLES specification requires the duplicate delete to be
  // silently ignored.
  const GLuint renderbuffers[2] = { global_depth_renderbuffer_,
                                    global_stencil_renderbuffer_ };
  PASS_THROUGH(this, DeleteFramebuffers, 1, &global_framebuffer_);
  PASS_THROUGH(this, DeleteRenderbuffers, 2, renderbuffers);
  global_framebuffer_ = 0;
  global_depth_renderbuffer_ = 0;
  global_stencil_renderbuffer_ = 0;
}

ShareGroupPtr GlesContext::GetShareGroup() const {
  LOG_ALWAYS_FATAL_IF(share_group_ == NULL);
  return share_group_;
}

void GlesContext::SetGLerror(GLenum error, const char* function,
                             int line_number, const char* fmt, ...) {
  const bool set_error = (error_ == GL_NO_ERROR);
  if (set_error) {
    error_ = error;
  }

  char msg[256];
  va_list args;
  va_start(args, fmt);
  vsnprintf(msg, sizeof(msg), fmt, args);
  va_end(args);

  char error_str[512];
  snprintf(error_str, sizeof(error_str), "%s:%d [ctx=%d]: %s", function,
           line_number, id_, msg);

  bool display_error = false;
  bool suppress_output = false;
  if (AreChecksEnabled()) {
    display_error = true;
  } else {
    const size_t num = error_counter_.size();
    if (num == kMaximumErrorCounterSize) {
      ALOGE("IMPORTANT: [ctx=%d] Too many errors!  Suppressing GLError output!",
            id_);
      // Add some dummy data until the error_counter_ exceeds the limit to
      // prevent this message from being printed again.
      uint32_t i = 0;
      while (error_counter_.size() == kMaximumErrorCounterSize) {
        error_counter_[i++] = 0;
      }
    } else if (num < kMaximumErrorCounterSize) {
      const uint32_t hash = Hash(error_str);
      uint32_t& count = error_counter_[hash];
      display_error = (count <= kErrorLimit);
      suppress_output = (count == kErrorLimit);
      ++count;
    }
  }

  if (display_error) {
    if (set_error) {
      ALOGW("[ctx=%d] GLES Error Set: %s (0x%x)", id_, GetEnumString(error),
            error);
    }
    ALOGE("%s", error_str);
    if (suppress_output) {
      ALOGE("IMPORTANT: Error \"%s\" will no longer be logged to stderr!",
            error_str);
    }
  }
}

GLenum GlesContext::GetGLerror() {
  const GLenum err = error_;
  error_ = GL_NO_ERROR;
  return err;
}

bool GlesContext::AreChecksEnabled() const {
  return checks_enabled_;
}

void GlesContext::Flush() {
  PASS_THROUGH(this, Flush);
}

void GlesContext::EnsureSurfaceReadyToDraw() const {
  if (surface_callback_ != NULL) {
    surface_callback_->EnsureBufferReady();
  }
}

void GlesContext::SetCurrentUserProgram(const ProgramDataPtr& program) {
  if (program == current_user_program_) {
    return;
  }

  if (program != NULL) {
    if (!program->Use(true)) {
      return;
    }
  }

  if (current_user_program_ != NULL) {
    current_user_program_->Use(false);
  }

  current_user_program_ = program;
}

bool GlesContext::CanDraw() const {
  if (version_ == kGles11) {
    if (!pointer_context_.IsArrayEnabled(kPositionVertexAttribute)) {
      return false;
    }
    if (IsEnabled(GL_MATRIX_PALETTE_OES)) {
      if (!pointer_context_.IsArrayEnabled(kWeightVertexAttribute)) {
        return false;
      }
      if (!pointer_context_.IsArrayEnabled(kMatrixIndexVertexAttribute)) {
        return false;
      }
      const PointerData* index_ptr = pointer_context_.GetPointerData(
          kMatrixIndexVertexAttribute);
      if (index_ptr->size == 0) {
        return false;
      }
    }
    return true;
  } else {
    return current_user_program_ != NULL;
  }
}

void GlesContext::DrawFullscreenQuad(GLuint texture, bool flip_v) {
  if (fullscreen_quad_ == NULL) {
    fullscreen_quad_ = new FullscreenQuad(this);
  }

  EnsureSurfaceReadyToDraw();

  fullscreen_quad_->Draw(texture, flip_v);
}

void GlesContext::Draw(DrawType draw, GLenum mode, GLint first, GLsizei count,
            GLenum type, const GLvoid* indices) {
  LOG_ALWAYS_FATAL_IF(draw != kDrawArrays && draw != kDrawElements);
  if (!CanDraw()) {
    return;
  }

  EnsureSurfaceReadyToDraw();

  bool program_uses_external_as_2d = false;
  PrepareProgramObject(mode, &program_uses_external_as_2d);
  texture_context_.PrepareTextures(version_ == kGles11,
                                   program_uses_external_as_2d);

  if (draw == kDrawArrays) {
    pointer_context_.PrepareBuffersForDrawArrays(first, count);
    PASS_THROUGH(this, DrawArrays, mode, first, count);
  } else {
    indices = pointer_context_.PrepareBuffersForDrawElements(count, type,
                                                             indices);
    PASS_THROUGH(this, DrawElements, mode, count, type, indices);
  }

  // Restore the buffer bindings as the pointer context may have changed them.
  PASS_THROUGH(this, BindBuffer, GL_ARRAY_BUFFER,
               share_group_->GetBufferGlobalName(array_buffer_binding_));
  PASS_THROUGH(this, BindBuffer, GL_ELEMENT_ARRAY_BUFFER,
               share_group_->GetBufferGlobalName(element_buffer_binding_));
  texture_context_.RestoreTextures();
  ClearProgramObject();
}

bool GlesContext::BindImageToTexture(GLenum target, EglImagePtr image) {
  TextureDataPtr texture = GetBoundTextureData(target);
  if (texture == NULL) {
    return false;
  }

  // Delete old texture object but only if it is not a target of a EGLImage
  const GLuint name =
      share_group_->GetTextureGlobalName(texture->GetLocalName());
  if (name) {
    if (!texture->IsEglImageAttached()) {
      PASS_THROUGH(this, DeleteTextures, 1, &name);
    }
  }

  // Map the texture to the EGL image texture.
  texture->AttachEglImage(image);
  share_group_->SetTextureGlobalName(texture->GetLocalName(),
                                     image->global_texture_name);

  // This function is always called to create a TEXTURE_EXTERNAL_OES,
  // Since we are binding the texture, ensure that we know what actual
  // global target this texture uses in the underlying implementation.
  texture_context_.SetTargetTexture(GL_TEXTURE_EXTERNAL_OES,
                                    texture->GetLocalName(),
                                    image->global_texture_target);

  // Bind the EGL image texture (which is now the same as the texture).
  PASS_THROUGH(this, BindTexture, image->global_texture_target,
               image->global_texture_name);
  return true;
}

bool GlesContext::BindImageToRenderbuffer(EglImagePtr image) {
  RenderbufferDataPtr rb = GetBoundRenderbufferData();
  if (rb == NULL) {
    return false;
  }

  rb->SetEglImage(image);

  // If the renderbuffer is attached to a framebuffer, change the
  // framebuffer attachment to point to the EGLImage texture object.
  if (rb->IsAttached()) {
    const bool save_and_restore =
        (framebuffer_binding_ != rb->GetAttachedFramebuffer());
    if (save_and_restore) {
      const GLuint global_name =
          share_group_->GetFramebufferGlobalName(rb->GetAttachedFramebuffer());
      PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER, global_name);
    }
    PASS_THROUGH(this, FramebufferTexture2D, GL_FRAMEBUFFER,
                 rb->GetAttachment(), image->global_texture_target,
                 image->global_texture_name, 0);
    if (save_and_restore) {
      const GLuint global_name =
          share_group_->GetFramebufferGlobalName(framebuffer_binding_);
      PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER, global_name);
    }
  }
  return true;
}


void GlesContext::BindFramebuffer(GLuint framebuffer) {
  framebuffer_binding_ = framebuffer;
  GLuint global_name = 0;

  if (framebuffer == 0) {
    // Use whatever framebuffer is set as the override framebuffer in place of
    // the default framebuffer.
    global_name = global_override_framebuffer_;
  } else {
    global_name = share_group_->GetFramebufferGlobalName(framebuffer);
  }
  PASS_THROUGH(this, BindFramebuffer, GL_FRAMEBUFFER, global_name);
}

void GlesContext::DrawTex(GLfloat x, GLfloat y, GLfloat z, GLfloat width,
                          GLfloat height) {
  // Backup vbo's
  const GLint array_buffer = array_buffer_binding_;
  const GLint element_buffer = element_buffer_binding_;
  PASS_THROUGH(this, BindBuffer, GL_ARRAY_BUFFER, 0);
  PASS_THROUGH(this, BindBuffer, GL_ELEMENT_ARRAY_BUFFER, 0);

  // Backup pointers
  const PointerContext::PointerDataVector pointers = pointer_context_.GetPointers();
  for (GLint index = 0; index < kNumVertexAttributeKeys; ++index) {
    pointer_context_.DisableArray(index);
    PASS_THROUGH(this, DisableVertexAttribArray, index);
  }

  // Setup projection matrix to draw in viewport aligned coordinates
  const emugl::Matrix projection_matrix = uniform_context_.GetProjectionMatrix();
  const GLint* viewport = viewport_.Get();
  uniform_context_.MutateProjectionMatrix() = emugl::Matrix::GenerateOrthographic(
      viewport[0], viewport[0] + viewport[2], viewport[1],
      viewport[1] + viewport[3], 0.f, -1.f);

  // Setup modelview matrix
  const emugl::Matrix model_view_matrix = uniform_context_.GetModelViewMatrix();
  uniform_context_.MutateModelViewMatrix().AssignIdentity();

  // Setup texture matrix
  emugl::Matrix texture_matrices[UniformContext::kMaxTextureUnits];
  for (GLint stage = 0; stage < UniformContext::kMaxTextureUnits; ++stage) {
    texture_matrices[stage] = uniform_context_.GetTextureMatrixByStage(stage);
    uniform_context_.MutateTextureMatrixByStage(stage).AssignIdentity();
  }

  // Backup |enabled_set_| and disable clip planes and lighting.
  const std::set<GLenum> enabled_set = enabled_set_;
  for (GLint i = 0; i < UniformContext::kMaxClipPlanes; ++i) {
    enabled_set_.erase(GL_CLIP_PLANE0 + i);
  }
  enabled_set_.erase(GL_LIGHTING);

  GLfloat texels[UniformContext::kMaxTextureUnits][8] = {};
  GLint num_textures = 0;
  for (GLint i = 0; i < UniformContext::kMaxTextureUnits; ++i) {
    if (!texture_context_.IsEnabled(GL_TEXTURE0 + i, GL_TEXTURE_2D)) {
      continue;
    }
    const GLint texture = texture_context_.GetTexture(GL_TEXTURE0 + i,
                                                      GL_TEXTURE_2D);
    const TextureDataPtr texture_data = share_group_->GetTextureData(texture);
    if (texture_data == NULL) {
      continue;
    }

    const GLint* crop_rect = texture_data->GetCropRect();
    const GLfloat tex_width = texture_data->GetWidth();
    const GLfloat tex_height = texture_data->GetHeight();

    texels[i][0] = crop_rect[0] / tex_width;
    texels[i][1] = crop_rect[1] / tex_height;

    texels[i][2] = crop_rect[0] / tex_width;
    texels[i][3] = (crop_rect[1] + crop_rect[3]) / tex_height;

    texels[i][4] = (crop_rect[0] + crop_rect[2]) / tex_width;
    texels[i][5] = (crop_rect[1] + crop_rect[3]) / tex_height;

    texels[i][6] = (crop_rect[0] + crop_rect[2]) / tex_width;
    texels[i][7] = crop_rect[1] / tex_height;


    pointer_context_.EnableArray(kTexCoord0VertexAttribute + i);
    PASS_THROUGH(this, EnableVertexAttribArray, kTexCoord0VertexAttribute + i);
    PASS_THROUGH(this, VertexAttribPointer, kTexCoord0VertexAttribute + i, 2,
                 GL_FLOAT, GL_FALSE, 0, texels[i]);
    num_textures++;
  }

  if (num_textures > 0) {
    z = ClampValue(z, 0.0f, 1.0f);
    const GLfloat vertices[] = {
      x, y, z,
      x, y + height, z,
      x + width, y + height, z,
      x + width, y, z,
    };
    pointer_context_.EnableArray(kPositionVertexAttribute);
    PASS_THROUGH(this, EnableVertexAttribArray, kPositionVertexAttribute);
    PASS_THROUGH(this, VertexAttribPointer, kPositionVertexAttribute, 3,
                 GL_FLOAT, GL_FALSE, 0, vertices);

    // DrawTex() needs texture environments etc, so we use GLES1 emulation to
    // avoid unnecessary complexity.
    Draw(kDrawArrays, GL_TRIANGLE_FAN, 0, 4, 0, 0);
  }

  // Restore enabled_set_
  enabled_set_ = enabled_set;

  // Restore matrix state
  uniform_context_.MutateProjectionMatrix() = projection_matrix;
  uniform_context_.MutateModelViewMatrix() = model_view_matrix;
  for (GLint stage = 0; stage < UniformContext::kMaxTextureUnits; ++stage) {
    uniform_context_.MutateTextureMatrixByStage(stage) =
        texture_matrices[stage];
  }

  // Restore pointers
  for (GLuint index = 0; index < pointers.size(); ++index) {
    const PointerData& ptr = pointers[index];
    PASS_THROUGH(this, BindBuffer, GL_ARRAY_BUFFER,
                 share_group_->GetBufferGlobalName(ptr.buffer_name));
    PASS_THROUGH(this, VertexAttribPointer, index, ptr.size, ptr.type,
                 ptr.normalize, ptr.stride, ptr.pointer);
    if (ptr.enabled) {
      PASS_THROUGH(this, EnableVertexAttribArray, index);
    } else {
      PASS_THROUGH(this, DisableVertexAttribArray, index);
    }
  }
  pointer_context_.SetPointers(pointers);

  // Restore vbo's
  PASS_THROUGH(this, BindBuffer, GL_ARRAY_BUFFER,
               share_group_->GetBufferGlobalName(array_buffer));
  PASS_THROUGH(this, BindBuffer, GL_ELEMENT_ARRAY_BUFFER,
               share_group_->GetBufferGlobalName(element_buffer));
}

BufferDataPtr GlesContext::GetBoundTargetBufferData(GLenum target) {
  if (target == GL_ARRAY_BUFFER) {
    return share_group_->GetBufferData(array_buffer_binding_);
  } else if (target == GL_ELEMENT_ARRAY_BUFFER) {
    return share_group_->GetBufferData(element_buffer_binding_);
  } else {
    return BufferDataPtr();
  }
}

FramebufferDataPtr GlesContext::GetBoundFramebufferData() {
  return share_group_->GetFramebufferData(framebuffer_binding_);
}

RenderbufferDataPtr GlesContext::GetBoundRenderbufferData() {
  return share_group_->GetRenderbufferData(renderbuffer_binding_);
}

TextureDataPtr GlesContext::GetBoundTextureData(GLenum target) {
  const GLuint name = texture_context_.GetBoundTexture(target);
  if (name == 0) {
    return texture_context_.GetDefaultTextureData(target);
  }
  return share_group_->GetTextureData(name);
}

GLenum GlesContext::GetEnabledTextureTarget(GLenum id) const {
  if (texture_context_.IsEnabled(id, GL_TEXTURE_CUBE_MAP)) {
    return GL_TEXTURE_CUBE_MAP;
  } else if (texture_context_.IsEnabled(id, GL_TEXTURE_EXTERNAL_OES)) {
    return GL_TEXTURE_EXTERNAL_OES;
  } else if (texture_context_.IsEnabled(id, GL_TEXTURE_2D)) {
    return GL_TEXTURE_2D;
  } else {
    return GL_NONE;
  }
}

ShaderConfig GlesContext::ConfigureShader(GLenum mode) {
  ShaderConfig cfg;

  for (int i = 0; i < UniformContext::kMaxTextureUnits; ++i) {
    const GLenum id = GL_TEXTURE0 + i;
    const GLenum target = GetEnabledTextureTarget(id);
    if (target == GL_NONE) {
      continue;
    }

    // Only generate texture shader if texture coord array is enabled, or
    // GL_TEXTURE_CUBE_MAP texture TexGen is enabled.
    // es_full_spec_1.1.12.pdf section 2.7
    // If the GL_TEXTURE_COORD_ARRAY is disabled, the current values specified
    // by glMultiTexCoord4{xf}() should be used. But most GLES1 implementations
    // will consider the texture unit is disabled. To be compatible to other
    // implementations, we will test the GL_TEXTURE_COORD_ARRAY.
    const GLuint index = TextureContext::GetTextureCoordAttrib(id);
    const bool texture_enabled = (target == GL_TEXTURE_CUBE_MAP) ?
                                 uniform_context_.GetTexGen(id)->enabled :
                                 pointer_context_.IsArrayEnabled(index);
    if (!texture_enabled) {
      continue;
    }

    cfg.any_texture_units_enabled = true;

    const TexEnv* env = uniform_context_.GetTexEnv(id);
    const TexGen* texgen = uniform_context_.GetTexGen(id);

    const GLuint texture = texture_context_.GetTexture(id, target);
    TextureDataPtr obj = share_group_->GetTextureData(texture);
    if (obj == NULL && texture == 0) {
      obj = texture_context_.GetDefaultTextureData(target);
    }

    ShaderConfig::TextureConfig& t = cfg.texture[i];
    t.enabled = true;
    t.mode = env->mode;
    t.target = target;
    if (t.mode != GL_COMBINE) {
      t.format = obj->GetFormat();
    }
    t.combine_rgb = env->combine_rgb;
    t.combine_alpha = env->combine_alpha;
    for (int j = 0; j < 3; ++j) {
      t.src_rgb[j] = env->src_rgb[j];
      t.src_alpha[j] = env->src_alpha[j];
      t.operand_rgb[j] = env->operand_rgb[j];
      t.operand_alpha[j] = env->operand_alpha[j];
    }

    if (target == GL_TEXTURE_CUBE_MAP) {
      t.texgen_mode = texgen->mode;
      t.texgen_enabled = texgen->enabled;
      cfg.any_texture_gen_normal_map |= texgen->mode == GL_NORMAL_MAP_OES;
      cfg.any_texture_gen_reflection_map |=
          texgen->mode == GL_REFLECTION_MAP_OES;
    }
  }

  for (int i = 0; i < UniformContext::kMaxLights; ++i) {
    const GLenum id = GL_LIGHT0 + i;
    if (IsEnabled(id)) {
      const Light* light = uniform_context_.GetLight(id);
      ShaderConfig::LightConfig& l = cfg.light[i];
      l.enabled = true;
      l.directional = light->IsDirectional();
      l.spot = light->IsSpot();
      l.attenuate = light->ShouldAttenuate();
    }
  }

  for (int i = 0; i < UniformContext::kMaxClipPlanes; ++i) {
    const GLenum id = GL_CLIP_PLANE0 + i;
    cfg.enable_clip_plane[i] = IsEnabled(id);
    cfg.any_clip_planes_enabled |= IsEnabled(id);
  }

  cfg.mode = mode;
  cfg.enable_alpha_test = IsEnabled(GL_ALPHA_TEST);
  if (cfg.enable_alpha_test) {
    cfg.alpha_func = uniform_context_.GetAlphaTest().func;
  }
  cfg.enable_color_material = IsEnabled(GL_COLOR_MATERIAL);
  cfg.enable_fog = IsEnabled(GL_FOG);
  if (cfg.enable_fog) {
    cfg.fog_mode = uniform_context_.GetFog().mode;
  }
  cfg.enable_light_model_two_side = IsEnabled(GL_LIGHT_MODEL_TWO_SIDE);
  cfg.enable_lighting = IsEnabled(GL_LIGHTING);
  cfg.enable_normalize = IsEnabled(GL_NORMALIZE);
  cfg.enable_point_smooth = IsEnabled(GL_POINT_SMOOTH);
  cfg.enable_point_sprite = IsEnabled(GL_POINT_SPRITE_OES);
  cfg.enable_matrix_palette = IsEnabled(GL_MATRIX_PALETTE_OES);
  if (cfg.enable_matrix_palette) {
    const PointerData* ptr = pointer_context_.GetPointerData(
        kMatrixIndexVertexAttribute);
    cfg.vertex_units = ptr->size;
  }
  return cfg;
}

GLuint GlesContext::CompileShader(GLenum shader_kind, const char* source) {
  GLuint object = PASS_THROUGH(this, CreateShader, shader_kind);
  PASS_THROUGH(this, ShaderSource, object, 1, &source, NULL);
  PASS_THROUGH(this, CompileShader, object);

  if (AreChecksEnabled()) {
    GLint compiled = 0;
    PASS_THROUGH(this, GetShaderiv, object, GL_COMPILE_STATUS, &compiled);
    if (compiled == GL_FALSE) {
      GLint len = 0, written = 0;
      PASS_THROUGH(this, GetShaderiv, object, GL_INFO_LOG_LENGTH, &len);
      char* log = new char[len];
      PASS_THROUGH(this, GetShaderInfoLog, object, len, &written, log);
      LOG_ALWAYS_FATAL("Unable to compile %s:\n%s\n%s",
                       GetEnumString(shader_kind), source, log);
      delete[] log;
    }
  }
  return object;
}

GLuint GlesContext::CompileProgram(GLuint vertex_shader,
                                   GLuint fragment_shader) {
  GLuint program = PASS_THROUGH(this, CreateProgram);
  PASS_THROUGH(this, AttachShader, program, vertex_shader);
  PASS_THROUGH(this, AttachShader, program, fragment_shader);
  for (int i = 0; i < kNumVertexAttributeKeys; ++i) {
    PASS_THROUGH(this, BindAttribLocation, program, i,
                 kVertexAttributeNames[i]);
  }
  PASS_THROUGH(this, LinkProgram, program);

  if (AreChecksEnabled()) {
    GLint link_status = 0;
    PASS_THROUGH(this, GetProgramiv, program, GL_LINK_STATUS, &link_status);
    if (link_status == GL_FALSE) {
      GLint len = 0, written = 0;
      PASS_THROUGH(this, GetProgramiv, program, GL_INFO_LOG_LENGTH, &len);
      char* log = new char[len];
      PASS_THROUGH(this, GetProgramInfoLog, program, len, &written, log);
      LOG_ALWAYS_FATAL("Unable to link:\nfragment:%d vertex:%d\n%s",
                       fragment_shader, vertex_shader, log);
      delete[] log;
    }
  }
  return program;
}

ProgramContext& GlesContext::BindProgramContext(GLenum mode) {
  // TODO(crbug.com/441922): Figure out actual maximum sizes for these two
  // buffers to minimize the fixed memory footprint we need.
  static const size_t kMaxShaderBufferSize = 65536;
  char buffer[kMaxShaderBufferSize];

  const ShaderConfig cfg = ConfigureShader(mode);

  GLuint* vs = vertex_shader_cache_.Get(cfg);
  if (!vs) {
    GenerateVertexShader(cfg, buffer, sizeof(buffer));
    const GLuint shader = CompileShader(GL_VERTEX_SHADER, buffer);
    vs = vertex_shader_cache_.Push(cfg, shader);
  }

  GLuint* fs = fragment_shader_cache_.Get(cfg);
  if (!fs) {
    GenerateFragmentShader(cfg, buffer, sizeof(buffer));
    const GLuint shader = CompileShader(GL_FRAGMENT_SHADER, buffer);
    fs = fragment_shader_cache_.Push(cfg, shader);
  }

  ProgramContext* program = program_cache_.Get(cfg);
  if (!program) {
    GLuint id = CompileProgram(*vs, *fs);
    program = program_cache_.Push(cfg, ProgramContext(this, id));
  }

  LOG_ALWAYS_FATAL_IF(program == NULL, "Program not created?");
  program->Bind();
  return *program;
}

void GlesContext::PrepareProgramObject(GLenum mode,
                                       bool* program_uses_external_as_2d) {
  if (current_user_program_ != NULL) {
    current_user_program_->PrepareForRendering(program_uses_external_as_2d);
    return;
  }

  ProgramContext& program = BindProgramContext(mode);
  uniform_context_.Bind(&program);

  if (pointer_context_.IsArrayEnabled(kPositionVertexAttribute)) {
    PASS_THROUGH(this, EnableVertexAttribArray, kPositionVertexAttribute);
  }
  if (pointer_context_.IsArrayEnabled(kNormalVertexAttribute)) {
    PASS_THROUGH(this, EnableVertexAttribArray, kNormalVertexAttribute);
  } else {
    GLfloat values[4];
    PASS_THROUGH(this, VertexAttrib3fv, kNormalVertexAttribute,
                 uniform_context_.GetNormal().GetFloatArray(values));
  }
  if (pointer_context_.IsArrayEnabled(kColorVertexAttribute)) {
    PASS_THROUGH(this, EnableVertexAttribArray, kColorVertexAttribute);
  } else {
    GLfloat values[4];
    PASS_THROUGH(this, VertexAttrib4fv, kColorVertexAttribute,
                 uniform_context_.GetColor().GetFloatArray(values));
  }
  for (int i = 0; i < UniformContext::kMaxTextureUnits; ++i) {
    if (GetEnabledTextureTarget(GL_TEXTURE0 + i) != GL_NONE) {
      const int attribute = kTexCoord0VertexAttribute + i;
      if (pointer_context_.IsArrayEnabled(attribute)) {
        PASS_THROUGH(this, EnableVertexAttribArray, attribute);
      }
    }
  }
  if (mode == GL_POINTS) {
    if (pointer_context_.IsArrayEnabled(kPointSizeVertexAttribute)) {
      PASS_THROUGH(this, EnableVertexAttribArray, kPointSizeVertexAttribute);
    } else {
      const PointParameters& params =
          uniform_context_.GetPointParameters();
      PASS_THROUGH(this, VertexAttrib1f, kPointSizeVertexAttribute,
                   params.current_size);
    }
  }
  if (pointer_context_.IsArrayEnabled(kWeightVertexAttribute)) {
    PASS_THROUGH(this, EnableVertexAttribArray, kWeightVertexAttribute);
  }
  if (pointer_context_.IsArrayEnabled(kMatrixIndexVertexAttribute)) {
    PASS_THROUGH(this, EnableVertexAttribArray, kMatrixIndexVertexAttribute);
  }
}

void GlesContext::ClearProgramObject() {
  if (current_user_program_ != NULL) {
    current_user_program_->CleanupAfterRendering();
    return;
  }

  if (pointer_context_.IsArrayEnabled(kPositionVertexAttribute)) {
    PASS_THROUGH(this, DisableVertexAttribArray, kPositionVertexAttribute);
  }
  if (pointer_context_.IsArrayEnabled(kNormalVertexAttribute)) {
    PASS_THROUGH(this, DisableVertexAttribArray, kNormalVertexAttribute);
  }
  if (pointer_context_.IsArrayEnabled(kColorVertexAttribute)) {
    PASS_THROUGH(this, DisableVertexAttribArray, kColorVertexAttribute);
  }
  for (int i = 0; i < UniformContext::kMaxTextureUnits; ++i) {
    if (GetEnabledTextureTarget(GL_TEXTURE0 + i) != GL_NONE) {
      const int attribute = kTexCoord0VertexAttribute + i;
      if (pointer_context_.IsArrayEnabled(attribute)) {
        PASS_THROUGH(this, DisableVertexAttribArray, attribute);
      }
    }
  }
  if (pointer_context_.IsArrayEnabled(kPointSizeVertexAttribute)) {
    PASS_THROUGH(this, DisableVertexAttribArray, kPointSizeVertexAttribute);
  }
  if (pointer_context_.IsArrayEnabled(kWeightVertexAttribute)) {
    PASS_THROUGH(this, DisableVertexAttribArray, kWeightVertexAttribute);
  }
  if (pointer_context_.IsArrayEnabled(kMatrixIndexVertexAttribute)) {
    PASS_THROUGH(this, DisableVertexAttribArray, kMatrixIndexVertexAttribute);
  }

  PASS_THROUGH(this, UseProgram, 0);
}

// Note: This should be kept in sync with EmulatedCompressedTextureFormats
// in gles_validate.cpp.
static const GLenum kEmulatedCompressedTextureFormats[] = {
    GL_PALETTE4_R5_G6_B5_OES,
    GL_PALETTE4_RGB5_A1_OES,
    GL_PALETTE4_RGB8_OES,
    GL_PALETTE4_RGBA4_OES,
    GL_PALETTE4_RGBA8_OES,
    GL_PALETTE8_R5_G6_B5_OES,
    GL_PALETTE8_RGB5_A1_OES,
    GL_PALETTE8_RGB8_OES,
    GL_PALETTE8_RGBA4_OES,
    GL_PALETTE8_RGBA8_OES,
    GL_ETC1_RGB8_OES,
};

void GlesContext::EnsureCompressedTextureFormatStateKnown() const {
  // TODO(crbug.com/426083): Load the list of compressed formats when needed
  // once for all contexts, since it should be consistent for all of them.
  // Once we know what compressed texture formats are supported, we do not have
  // to compute it again.
  if (!emulated_compressed_texture_formats_.empty()) {
    return;
  }

  // Get the list of formats supported by the underlying implementation.
  GLint underlying_num_compressed_textures = 0;
  PASS_THROUGH(this, GetIntegerv, GL_NUM_COMPRESSED_TEXTURE_FORMATS,
               &underlying_num_compressed_textures);

  std::vector<GLint> underlying_compressed_textures_supported(
      underlying_num_compressed_textures);

  if (underlying_num_compressed_textures) {
    PASS_THROUGH(this, GetIntegerv, GL_COMPRESSED_TEXTURE_FORMATS,
                 &underlying_compressed_textures_supported[0]);
  }

  // Android/GLES1 requires support for a specific list of formats. If they are
  // not supported in the underlying implementation we will have to emulate
  // support by converting texture data.
  const size_t count_emulated_formats =
      sizeof(kEmulatedCompressedTextureFormats) /
      sizeof(kEmulatedCompressedTextureFormats[0]);
  emulated_compressed_texture_formats_.reserve(count_emulated_formats);
  for (size_t i = 0; i < count_emulated_formats; ++i) {
    GLenum format = kEmulatedCompressedTextureFormats[i];
    std::vector<GLint>::const_iterator iter =
        std::find(underlying_compressed_textures_supported.begin(),
                  underlying_compressed_textures_supported.end(), format);
    if (iter == underlying_compressed_textures_supported.end()) {
      emulated_compressed_texture_formats_.push_back(format);
    }
  }

  // Build the list of texture formats we support by combining the list from the
  // underlying implementation with the list of formats we will emulate.
  supported_compressed_texture_formats_.reserve(
      emulated_compressed_texture_formats_.size() +
      underlying_compressed_textures_supported.size());
  copy(emulated_compressed_texture_formats_.begin(),
       emulated_compressed_texture_formats_.end(),
       back_inserter(supported_compressed_texture_formats_));
  copy(underlying_compressed_textures_supported.begin(),
       underlying_compressed_textures_supported.end(),
       back_inserter(supported_compressed_texture_formats_));
}

void GlesContext::EnsureUnderlyingExtensionsKnown() const {
  // TODO(crbug.com/426083): Load the list of extensions when needed once for
  // all contexts, since it should be consistent for all of them.
  if (global_extensions_) {
    return;
  }
  global_extensions_ = reinterpret_cast<const char *>(
      PASS_THROUGH(this, GetString, GL_EXTENSIONS));
  supports_packed_depth_stencil_ =
      strstr(global_extensions_, "OES_packed_depth_stencil") != NULL;
}


bool GlesContext::IsCompressedFormatEmulationNeeded(GLenum format) const {
  EnsureCompressedTextureFormatStateKnown();

  TextureFormats::const_iterator iter =
      std::find(emulated_compressed_texture_formats_.begin(),
                emulated_compressed_texture_formats_.end(), format);

  return iter != emulated_compressed_texture_formats_.end();
}

template <typename T>
bool GlesContext::GetValue(GLenum value, T* data) const {
  switch (value) {
    // Current framebuffer object state.
    // Note we cache the default framebuffer state, but do not currently cache
    // the state of any bound framebuffer.
    case GL_ALPHA_BITS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_alpha_bits_.Get());
        return true;
      }
      return false;
    case GL_BLUE_BITS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_blue_bits_.Get());
        return true;
      }
      return false;
    case GL_DEPTH_BITS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_depth_bits_.Get());
        return true;
      }
      return false;
    case GL_GREEN_BITS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_green_bits_.Get());
        return true;
      }
      return false;
    case GL_RED_BITS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_red_bits_.Get());
        return true;
      }
      return false;
    case GL_STENCIL_BITS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_stencil_bits_.Get());
        return true;
      }
      return false;
    case GL_SAMPLE_BUFFERS:
      if (framebuffer_binding_ == 0) {
        Convert(data, default_framebuffer_sample_buffers_.Get());
        return true;
      }
      return false;

    // This state matches what can be obtained by calling IsEnabled.
    case GL_BLEND:
    case GL_CULL_FACE:
    case GL_DEPTH_TEST:
    case GL_DITHER:
    case GL_POLYGON_OFFSET_FILL:
    case GL_SAMPLE_ALPHA_TO_COVERAGE:
    case GL_SAMPLE_COVERAGE:
    case GL_SCISSOR_TEST:
case GL_STENCIL_TEST:
      Convert(data, IsEnabled(value));
      return true;

    // This state is GLES1 state we must emulate..
    case GL_MAX_CLIP_PLANES:
      Convert(data, static_cast<GLint>(UniformContext::kMaxClipPlanes));
      return true;

    case GL_MAX_LIGHTS:
      Convert(data, static_cast<GLint>(UniformContext::kMaxLights));
      return true;

    // TODO(crbug.com/441923): We should use the underlying implementation
    // values for GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS and
    // GL_MAX_TEXTURE_IMAGE_UNITS.
    case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
    case GL_MAX_TEXTURE_IMAGE_UNITS:
    case GL_MAX_TEXTURE_UNITS:
      Convert(data, static_cast<GLint>(UniformContext::kMaxTextureUnits));
      return true;

    // palette matrix relared values:
    case GL_CURRENT_PALETTE_MATRIX_OES:
      Convert(data, uniform_context_.GetCurrentPaletteMatrix());
      return true;
    case GL_MAX_PALETTE_MATRICES_OES:
      Convert(data, UniformContext::kMaxPaletteMatricesOES);
      return true;
    case GL_MAX_VERTEX_UNITS_OES:
      Convert(data, UniformContext::kMaxVertexUnitsOES);
      return true;

    case GL_MATRIX_MODE:
      Convert(data, static_cast<GLuint>(uniform_context_.GetMatrixMode()));
      return true;

    case GL_MODELVIEW_MATRIX: {
        GLfloat tmp[emugl::Matrix::kEntries];
        uniform_context_.GetModelViewMatrix().GetColumnMajorArray(
            tmp, emugl::Matrix::kEntries);
        Convert(data, tmp);
        return true;
      }

    case GL_PROJECTION_MATRIX: {
        GLfloat tmp[emugl::Matrix::kEntries];
        uniform_context_.GetProjectionMatrix().GetColumnMajorArray(
            tmp, emugl::Matrix::kEntries);
        Convert(data, tmp);
        return true;
      }

    case GL_TEXTURE_MATRIX: {
        GLfloat tmp[emugl::Matrix::kEntries];
        uniform_context_.GetTextureMatrix().GetColumnMajorArray(
            tmp, emugl::Matrix::kEntries);
        Convert(data, tmp);
        return true;
      }

    case GL_SMOOTH_POINT_SIZE_RANGE:
      Convert(data, aliased_point_size_range_.Get());
      return true;

    case GL_CLIENT_ACTIVE_TEXTURE:
      Convert(data, texture_context_.GetClientActiveTexture());
      return true;

    // This state is GLES2 state that is cached purely for performance reasons.
    // Note: C++11 will allow us to eliminate duplicate knowledge of the
    // mapping by being able to the pattern:
    //   case decltype(foo::kValue):
    //     Convert(data, foo.Get());
    case GL_ACTIVE_TEXTURE:
      Convert(data, texture_context_.GetActiveTexture());
      return true;

    case GL_ALIASED_LINE_WIDTH_RANGE:
      Convert(data, aliased_line_width_range_.Get());
      return true;

    case GL_ALIASED_POINT_SIZE_RANGE:
      Convert(data, aliased_point_size_range_.Get());
      return true;

    case GL_ARRAY_BUFFER_BINDING:
      Convert(data, array_buffer_binding_);
      return true;

    case GL_BLEND_DST_ALPHA:
      Convert(data, blend_func_dst_alpha_.Get());
      return true;

    case GL_BLEND_DST_RGB:
      Convert(data, blend_func_dst_rgb_.Get());
      return true;

    case GL_BLEND_SRC_ALPHA:
      Convert(data, blend_func_src_alpha_.Get());
      return true;

    case GL_BLEND_SRC_RGB:
      Convert(data, blend_func_src_rgb_.Get());
      return true;

    case GL_COLOR_CLEAR_VALUE:
      Convert(data, color_clear_value_.Get());
      return true;

    case GL_COLOR_WRITEMASK:
      Convert(data, color_writemask_.Get());
      return true;

    case GL_CULL_FACE_MODE:
      Convert(data, cull_face_mode_.Get());
      return true;

    case GL_CURRENT_PROGRAM:
      if (current_user_program_ != NULL) {
        Convert(data, static_cast<GLint>(
            current_user_program_->GetLocalName()));
      } else {
        *data = 0;
      }
      return true;

    case GL_DEPTH_CLEAR_VALUE:
      Convert(data, depth_clear_value_.Get());
      return true;

    case GL_DEPTH_FUNC:
      Convert(data, depth_func_.Get());
      return true;

    case GL_DEPTH_RANGE:
      Convert(data, depth_range_.Get());
      return true;

    case GL_DEPTH_WRITEMASK:
      Convert(data, depth_writemask_.Get());
      return true;

    case GL_ELEMENT_ARRAY_BUFFER_BINDING:
      Convert(data, element_buffer_binding_);
      return true;

    case GL_FRAMEBUFFER_BINDING:
      Convert(data, framebuffer_binding_);
      return true;

    case GL_FRONT_FACE:
      Convert(data, front_face_.Get());
      return true;

    case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
      Convert(data, GL_UNSIGNED_BYTE);
      return true;

    case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
      Convert(data, GL_RGBA);
      return true;

    case GL_LINE_WIDTH:
      Convert(data, line_width_.Get());
      return true;

    case GL_GENERATE_MIPMAP_HINT:
      Convert(data, generate_mipmap_hint_.Get());
      return true;

    case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
      Convert(data, max_cube_map_texture_size_.Get());
      return true;

    case GL_MAX_RENDERBUFFER_SIZE:
      Convert(data, max_renderbuffer_size_.Get());
      return true;

    case GL_MAX_TEXTURE_SIZE:
      Convert(data, max_texture_size_.Get());
      return true;

    case GL_MAX_VERTEX_ATTRIBS:
      Convert(data, max_vertex_attribs_.Get());
      return true;

    case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
      Convert(data, max_vertex_texture_image_units_.Get());
      return true;

    case GL_MAX_VIEWPORT_DIMS:
      Convert(data, max_viewport_dims_.Get());
      return true;

    case GL_PACK_ALIGNMENT:
      Convert(data, pixel_store_pack_alignment_.Get());
      return true;

    case GL_POLYGON_OFFSET_FACTOR:
      Convert(data, polygon_offset_factor_.Get());
      return true;

    case GL_POLYGON_OFFSET_UNITS:
      Convert(data, polygon_offset_units_.Get());
      return true;

    case GL_RENDERBUFFER_BINDING:
      Convert(data, renderbuffer_binding_);
      return true;

    case GL_SAMPLE_COVERAGE_VALUE:
      Convert(data, sample_coverage_value_.Get());
      return true;

    case GL_SAMPLE_COVERAGE_INVERT:
      Convert(data, sample_coverage_invert_.Get());
      return true;

    case GL_SCISSOR_BOX:
      Convert(data, scissor_box_.Get());
      return true;

    case GL_STENCIL_FUNC:
      Convert(data, stencil_func_.Get());
      return true;

    case GL_STENCIL_REF:
      Convert(data, stencil_ref_.Get());
      return true;

    case GL_STENCIL_VALUE_MASK:
      Convert(data, stencil_value_mask_.Get());
      return true;

    case GL_TEXTURE_BINDING_CUBE_MAP:
      Convert(data, texture_context_.GetBoundTexture(GL_TEXTURE_CUBE_MAP));
      return true;

    case GL_TEXTURE_BINDING_2D:
      Convert(data, texture_context_.GetBoundTexture(GL_TEXTURE_2D));
      return true;

    case GL_TEXTURE_BINDING_EXTERNAL_OES:
      Convert(data, texture_context_.GetBoundTexture(GL_TEXTURE_EXTERNAL_OES));
      return true;

    case GL_UNPACK_ALIGNMENT:
      Convert(data, pixel_store_unpack_alignment_.Get());
      return true;

    case GL_VIEWPORT:
      Convert(data, viewport_.Get());
      return true;

    // The compressed texture format state is special.
    // GLES1 mandates that ten specific formats must be supported.
    // GLES2 makes support entirely optional.
    case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
      EnsureCompressedTextureFormatStateKnown();
      Convert(data, static_cast<GLint>(supported_compressed_texture_formats_.size()));
      return true;

    case GL_COMPRESSED_TEXTURE_FORMATS:
      EnsureCompressedTextureFormatStateKnown();
      Convert(data, supported_compressed_texture_formats_.begin(),
              supported_compressed_texture_formats_.end());
      return true;
  }

  const PointerData* ptr = NULL;
  switch (value) {
    case GL_VERTEX_ARRAY_BUFFER_BINDING:
    case GL_VERTEX_ARRAY_SIZE:
    case GL_VERTEX_ARRAY_STRIDE:
    case GL_VERTEX_ARRAY_TYPE:
      ptr = pointer_context_.GetPointerData(kPositionVertexAttribute);
      break;
    case GL_NORMAL_ARRAY_BUFFER_BINDING:
    case GL_NORMAL_ARRAY_STRIDE:
    case GL_NORMAL_ARRAY_TYPE:
      ptr = pointer_context_.GetPointerData(kNormalVertexAttribute);
      break;
    case GL_COLOR_ARRAY_BUFFER_BINDING:
    case GL_COLOR_ARRAY_SIZE:
    case GL_COLOR_ARRAY_STRIDE:
    case GL_COLOR_ARRAY_TYPE:
      ptr = pointer_context_.GetPointerData(kColorVertexAttribute);
      break;
    case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
    case GL_TEXTURE_COORD_ARRAY_SIZE:
    case GL_TEXTURE_COORD_ARRAY_STRIDE:
    case GL_TEXTURE_COORD_ARRAY_TYPE:
      ptr = pointer_context_.GetPointerData(
          texture_context_.GetClientActiveTextureCoordAttrib());
      break;
    case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
    case GL_POINT_SIZE_ARRAY_STRIDE_OES:
    case GL_POINT_SIZE_ARRAY_TYPE_OES:
      ptr = pointer_context_.GetPointerData(kPointSizeVertexAttribute);
      break;
    case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
    case GL_WEIGHT_ARRAY_SIZE_OES:
    case GL_WEIGHT_ARRAY_STRIDE_OES:
    case GL_WEIGHT_ARRAY_TYPE_OES:
      ptr = pointer_context_.GetPointerData(kWeightVertexAttribute);
      break;
    case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
    case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
    case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
    case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
      ptr = pointer_context_.GetPointerData(kMatrixIndexVertexAttribute);
      break;
    default:
      return false;
  }

  switch (value) {
    case GL_VERTEX_ARRAY_BUFFER_BINDING:
    case GL_NORMAL_ARRAY_BUFFER_BINDING:
    case GL_COLOR_ARRAY_BUFFER_BINDING:
    case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
    case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
    case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
    case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
      Convert(data, ptr ? ptr->buffer_name : 0);
      return true;

    case GL_VERTEX_ARRAY_STRIDE:
    case GL_NORMAL_ARRAY_STRIDE:
    case GL_COLOR_ARRAY_STRIDE:
    case GL_TEXTURE_COORD_ARRAY_STRIDE:
    case GL_POINT_SIZE_ARRAY_STRIDE_OES:
    case GL_WEIGHT_ARRAY_STRIDE_OES:
    case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
      Convert(data, ptr ? ptr->stride : 0);
      return true;

    case GL_VERTEX_ARRAY_SIZE:
    case GL_COLOR_ARRAY_SIZE:
    case GL_TEXTURE_COORD_ARRAY_SIZE:
    case GL_WEIGHT_ARRAY_SIZE_OES:
    case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
      Convert(data, ptr ? ptr->size : 0);
      return true;

    case GL_VERTEX_ARRAY_TYPE:
    case GL_NORMAL_ARRAY_TYPE:
    case GL_COLOR_ARRAY_TYPE:
    case GL_TEXTURE_COORD_ARRAY_TYPE:
    case GL_POINT_SIZE_ARRAY_TYPE_OES:
    case GL_WEIGHT_ARRAY_TYPE_OES:
    case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
      Convert(data, ptr ? ptr->type : 0);
      return true;
  }

  LOG_ALWAYS_FATAL("%s: Attempt to get %s (0x%x)", __FUNCTION__,
                   GetEnumString(value), value);
  return false;
}

bool GlesContext::GetBooleanv(GLenum pname, GLboolean* data) const {
  return GetValue(pname, data);
}

bool GlesContext::GetFloatv(GLenum pname, GLfloat* data) const {
  return GetValue(pname, data);
}

bool GlesContext::GetIntegerv(GLenum pname, GLint* data) const {
  return GetValue(pname, data);
}

bool GlesContext::GetFixedv(GLenum pname, GLfixed* data) const {
  return GetValue(pname, data);
}

const GLubyte* GlesContext::GetString(GLenum pname) const {
  const char* str = NULL;
  switch (pname) {
    case GL_VENDOR:
      str = "Chromium";
      break;
    case GL_RENDERER:
      str = "Chromium";
      break;
    case GL_VERSION:
      if (version_ == kGles11) {
        str = "OpenGL ES 1.1 Chromium";
      } else {
        str = "OpenGL ES 2.0 Chromium";
      }
      break;
    case GL_EXTENSIONS:
      if (version_ == kGles11) {
        str = "GL_OES_EGL_image "
              "GL_OES_blend_equation_separate "
              "GL_OES_blend_func_separate "
              "GL_OES_blend_subtract "
              "GL_OES_byte_coordinates "
              "GL_OES_compressed_ETC1_RGB8_texture "
              "GL_OES_depth24 "
              "GL_OES_depth32 "
              "GL_OES_draw_texture "
              "GL_OES_element_index_uint "
              "GL_OES_framebuffer_object "
              "GL_OES_matrix_palette "
              "GL_EXT_packed_depth_stencil "
              "GL_OES_point_size_array "
              "GL_OES_point_sprite "
              "GL_OES_rgb8_rgba8 "
              "GL_OES_single_precision "
              "GL_OES_stencil1 "
              "GL_OES_stencil4 "
              "GL_OES_stencil8 "
              "GL_OES_stencil_wrap "
              "GL_OES_texture_cube_map "
              "GL_OES_texture_env_crossbar "
              "GL_OES_texture_npot ";
      } else {
        str = "GL_OES_EGL_image "
              "GL_OES_EGL_image_external "
              "GL_OES_compressed_ETC1_RGB8_texture "
              "GL_OES_depth24 "
              "GL_OES_depth32 "
              "GL_OES_depth_texture "
              "GL_OES_element_index_uint "
              "GL_OES_packed_depth_stencil "
              "GL_OES_texture_npot ";
      }
      break;
    case GL_SHADING_LANGUAGE_VERSION:
      str = "OpenGL ES GLSL ES 1.0 Chromium";
      break;
    default:
      LOG_ALWAYS_FATAL("Unsupported string parameter: %s (0x%x)",
                       GetEnumString(pname), pname);
  }
  return reinterpret_cast<const GLubyte*>(str);
}