aw: Refactor hardware init

android_webview/browser/scoped_app_gl_state_restore.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 "android_webview/browser/scoped_app_gl_state_restore.h"
 
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
+#include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_stub.h"
 
 namespace android_webview {
 
 namespace {
 
 // "App" context is a bit of a stretch. Basically we use this context while
 // saving and restoring the App GL state.
 class AppContextSurface {
@@ skipping 28 matching lines @@
   else
     glDisable(cap);
 }
 
 bool g_globals_initialized = false;
 GLint g_gl_max_texture_units = 0;
 bool g_supports_oes_vertex_array_object = false;
 
 }  // namespace
 
-ScopedAppGLStateRestore::ScopedAppGLStateRestore(CallMode mode) : mode_(mode) {
+namespace internal {
+
+class ScopedAppGLStateRestoreImpl {
+ public:
+  ScopedAppGLStateRestoreImpl(ScopedAppGLStateRestore::CallMode mode);
+  ~ScopedAppGLStateRestoreImpl();
+
+  bool stencil_enabled() const { return stencil_test_; }
+  GLint framebuffer_binding_ext() const { return framebuffer_binding_ext_; }
+
+ private:
+  const ScopedAppGLStateRestore::CallMode mode_;
+
+  GLint pack_alignment_;
+  GLint unpack_alignment_;
+
+  struct {
+    GLint enabled;
+    GLint size;
+    GLint type;
+    GLint normalized;
+    GLint stride;
+    GLvoid* pointer;
+    GLint vertex_attrib_array_buffer_binding;
+    GLfloat current_vertex_attrib[4];
+  } vertex_attrib_[3];
+
+  GLint vertex_array_buffer_binding_;
+  GLint index_array_buffer_binding_;
+
+  GLboolean depth_test_;
+  GLboolean cull_face_;
+  GLint cull_face_mode_;
+  GLboolean color_mask_[4];
+  GLfloat color_clear_[4];
+  GLfloat depth_clear_;
+  GLint current_program_;
+  GLint depth_func_;
+  GLboolean depth_mask_;
+  GLfloat depth_rage_[2];
+  GLint front_face_;
+  GLint hint_generate_mipmap_;
+  GLfloat line_width_;
+  GLfloat polygon_offset_factor_;
+  GLfloat polygon_offset_units_;
+  GLfloat sample_coverage_value_;
+  GLboolean sample_coverage_invert_;
+
+  GLboolean enable_dither_;
+  GLboolean enable_polygon_offset_fill_;
+  GLboolean enable_sample_alpha_to_coverage_;
+  GLboolean enable_sample_coverage_;
+
+  // Not saved/restored in MODE_DRAW.
+  GLboolean blend_enabled_;
+  GLint blend_src_rgb_;
+  GLint blend_src_alpha_;
+  GLint blend_dest_rgb_;
+  GLint blend_dest_alpha_;
+  GLint active_texture_;
+  GLint viewport_[4];
+  GLboolean scissor_test_;
+  GLint scissor_box_[4];
+
+  GLboolean stencil_test_;
+  GLint stencil_func_;
+  GLint stencil_mask_;
+  GLint stencil_ref_;
+
+  GLint framebuffer_binding_ext_;
+
+  struct TextureBindings {
+    GLint texture_2d;
+    GLint texture_cube_map;
+    GLint texture_external_oes;
+    // TODO(boliu): TEXTURE_RECTANGLE_ARB
+  };
+
+  std::vector<TextureBindings> texture_bindings_;
+
+  GLint vertex_array_bindings_oes_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAppGLStateRestoreImpl);
+};
+
+ScopedAppGLStateRestoreImpl::ScopedAppGLStateRestoreImpl(
+    ScopedAppGLStateRestore::CallMode mode)
+    : mode_(mode) {
   TRACE_EVENT0("android_webview", "AppGLStateSave");
   MakeAppContextCurrent();
 
   if (!g_globals_initialized) {
     g_globals_initialized = true;
 
     glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &g_gl_max_texture_units);
     DCHECK_GT(g_gl_max_texture_units, 0);
 
     std::string extensions(
         reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
     g_supports_oes_vertex_array_object =
         extensions.find("GL_OES_vertex_array_object") != std::string::npos;
   }
 
   glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &vertex_array_buffer_binding_);
   glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &index_array_buffer_binding_);
 
   switch(mode_) {
-    case MODE_DRAW:
+    case ScopedAppGLStateRestore::MODE_DRAW:
       DCHECK_EQ(0, vertex_array_buffer_binding_);
       DCHECK_EQ(0, index_array_buffer_binding_);
       break;
-    case MODE_RESOURCE_MANAGEMENT:
+    case ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT:
       glGetBooleanv(GL_BLEND, &blend_enabled_);
       glGetIntegerv(GL_BLEND_SRC_RGB, &blend_src_rgb_);
       glGetIntegerv(GL_BLEND_SRC_ALPHA, &blend_src_alpha_);
       glGetIntegerv(GL_BLEND_DST_RGB, &blend_dest_rgb_);
       glGetIntegerv(GL_BLEND_DST_ALPHA, &blend_dest_alpha_);
       glGetIntegerv(GL_VIEWPORT, viewport_);
       glGetBooleanv(GL_SCISSOR_TEST, &scissor_test_);
       glGetIntegerv(GL_SCISSOR_BOX, scissor_box_);
       break;
   }
@@ skipping 64 matching lines @@
     glGetVertexAttribPointerv(
         i, GL_VERTEX_ATTRIB_ARRAY_POINTER, &vertex_attrib_[i].pointer);
     glGetVertexAttribiv(i,
                         GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
                         &vertex_attrib_[i].vertex_attrib_array_buffer_binding);
     glGetVertexAttribfv(
         i, GL_CURRENT_VERTEX_ATTRIB, vertex_attrib_[i].current_vertex_attrib);
   }
 }
 
-ScopedAppGLStateRestore::~ScopedAppGLStateRestore() {
+ScopedAppGLStateRestoreImpl::~ScopedAppGLStateRestoreImpl() {
   TRACE_EVENT0("android_webview", "AppGLStateRestore");
   MakeAppContextCurrent();
 
   glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer_binding_ext_);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_array_buffer_binding_);
 
   if (g_supports_oes_vertex_array_object)
     glBindVertexArrayOES(0);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(vertex_attrib_); ++i) {
@@ skipping 54 matching lines @@
   glPolygonOffset(polygon_offset_factor_, polygon_offset_units_);
   glSampleCoverage(sample_coverage_value_, sample_coverage_invert_);
 
   GLEnableDisable(GL_DITHER, enable_dither_);
   GLEnableDisable(GL_POLYGON_OFFSET_FILL, enable_polygon_offset_fill_);
   GLEnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
                   enable_sample_alpha_to_coverage_);
   GLEnableDisable(GL_SAMPLE_COVERAGE, enable_sample_coverage_);
 
   switch(mode_) {
-    case MODE_DRAW:
+    case ScopedAppGLStateRestore::MODE_DRAW:
       // No-op.
       break;
-    case MODE_RESOURCE_MANAGEMENT:
+    case ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT:
       GLEnableDisable(GL_BLEND, blend_enabled_);
       glBlendFuncSeparate(
           blend_src_rgb_, blend_dest_rgb_, blend_src_alpha_, blend_dest_alpha_);
 
       glViewport(viewport_[0], viewport_[1], viewport_[2], viewport_[3]);
 
       GLEnableDisable(GL_SCISSOR_TEST, scissor_test_);
 
       glScissor(
           scissor_box_[0], scissor_box_[1], scissor_box_[2], scissor_box_[3]);
       break;
   }
 
   GLEnableDisable(GL_STENCIL_TEST, stencil_test_);
   glStencilFunc(stencil_func_, stencil_mask_, stencil_ref_);
 }
 
+}  // namespace internal
+
+ScopedAppGLStateRestore::ScopedAppGLStateRestore(CallMode mode)
+    : impl_(new internal::ScopedAppGLStateRestoreImpl(mode)) {
+}
+
+ScopedAppGLStateRestore::~ScopedAppGLStateRestore() {}
+
+bool ScopedAppGLStateRestore::stencil_enabled() const {
+  return impl_->stencil_enabled();
+}
+int ScopedAppGLStateRestore::framebuffer_binding_ext() const {
+  return impl_->framebuffer_binding_ext();
+}
+
 }  // namespace android_webview