Bring back Leandro's GL state restore

android_webview/browser/in_process_renderer/in_process_view_renderer.cc

 // Copyright (c) 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/in_process_renderer/in_process_view_renderer.h"
 
 #include <android/bitmap.h>
 
 #include "android_webview/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
 #include "base/android/jni_android.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/renderer/android/synchronous_compositor.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_f.h"
 #include "ui/gl/gl_bindings.h"
 
+// TODO(leandrogracia): Borrowed from gl2ext.h. Cannot be included due to
+// conflicts with  gl_bindings.h and the EGL library methods
+// (eglGetCurrentContext).
+#ifndef GL_TEXTURE_EXTERNAL_OES
+#define GL_TEXTURE_EXTERNAL_OES 0x8D65
+#endif
+
+#ifndef GL_TEXTURE_BINDING_EXTERNAL_OES
+#define GL_TEXTURE_BINDING_EXTERNAL_OES 0x8D67
+#endif
+
 using base::android::AttachCurrentThread;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 using content::Compositor;
 using content::ContentViewCore;
 
 namespace android_webview {
 
 namespace {
+
+class GLStateRestore {
+ public:
+  GLStateRestore() {
+    glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES,
+                  &texture_external_oes_binding_);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &vertex_array_buffer_binding_);
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING,
+                  &index_array_buffer_binding_);
+    glGetIntegerv(GL_PACK_ALIGNMENT, &pack_alignment_);
+    glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack_alignment_);
+
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(vertex_attrib_); ++i) {
+      glGetVertexAttribiv(
+          i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &vertex_attrib_[i].enabled);
+      glGetVertexAttribiv(
+          i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &vertex_attrib_[i].size);
+      glGetVertexAttribiv(
+          i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &vertex_attrib_[i].type);
+      glGetVertexAttribiv(
+          i, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &vertex_attrib_[i].normalized);
+      glGetVertexAttribiv(
+          i, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &vertex_attrib_[i].stride);
+      glGetVertexAttribPointerv(
+          i, GL_VERTEX_ATTRIB_ARRAY_POINTER, &vertex_attrib_[i].pointer);
+    }
+
+    glGetBooleanv(GL_DEPTH_TEST, &depth_test_);
+    glGetBooleanv(GL_CULL_FACE, &cull_face_);
+    glGetBooleanv(GL_COLOR_WRITEMASK, color_mask_);
+    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_ACTIVE_TEXTURE, &active_texture_);
+    glGetIntegerv(GL_VIEWPORT, viewport_);
+    glGetBooleanv(GL_SCISSOR_TEST, &scissor_test_);
+    glGetIntegerv(GL_SCISSOR_BOX, scissor_box_);
+    glGetIntegerv(GL_CURRENT_PROGRAM, &current_program_);
+
+    DCHECK_EQ(0, vertex_array_buffer_binding_);
+    DCHECK_EQ(0, index_array_buffer_binding_);
+  }
+
+  ~GLStateRestore() {
+    glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_external_oes_binding_);
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_array_buffer_binding_);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_array_buffer_binding_);
+    glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment_);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment_);
+
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(vertex_attrib_); ++i) {
+      glVertexAttribPointer(i,
+                            vertex_attrib_[i].size,
+                            vertex_attrib_[i].type,
+                            vertex_attrib_[i].normalized,
+                            vertex_attrib_[i].stride,
+                            vertex_attrib_[i].pointer);
+
+      if (vertex_attrib_[i].enabled) {
+        glEnableVertexAttribArray(i);
+      } else {
+        glDisableVertexAttribArray(i);
+      }
+    }
+
+    if (depth_test_) {
+      glEnable(GL_DEPTH_TEST);
+    } else {
+      glDisable(GL_DEPTH_TEST);
+    }
+
+    if (cull_face_) {
+      glEnable(GL_CULL_FACE);
+    } else {
+      glDisable(GL_CULL_FACE);
+    }
+
+    glColorMask(color_mask_[0], color_mask_[1], color_mask_[2], color_mask_[3]);
+
+    if (blend_enabled_) {
+      glEnable(GL_BLEND);
+    } else {
+      glDisable(GL_BLEND);
+    }
+
+    glBlendFuncSeparate(
+        blend_src_rgb_, blend_dest_rgb_, blend_src_alpha_, blend_dest_alpha_);
+    glActiveTexture(active_texture_);
+
+    glViewport(viewport_[0], viewport_[1], viewport_[2], viewport_[3]);
+
+    if (scissor_test_) {
+      glEnable(GL_SCISSOR_TEST);
+    } else {
+      glDisable(GL_SCISSOR_TEST);
+    }
+
+    glScissor(
+        scissor_box_[0], scissor_box_[1], scissor_box_[2], scissor_box_[3]);
+
+    glUseProgram(current_program_);
+  }
+
+ private:
+  GLint texture_external_oes_binding_;
+  GLint vertex_array_buffer_binding_;
+  GLint index_array_buffer_binding_;
+  GLint pack_alignment_;
+  GLint unpack_alignment_;
+
+  struct {
+    GLint enabled;
+    GLint size;
+    GLint type;
+    GLint normalized;
+    GLint stride;
+    GLvoid* pointer;
+  } vertex_attrib_[3];
+
+  GLboolean depth_test_;
+  GLboolean cull_face_;
+  GLboolean color_mask_[4];
+  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];
+  GLint current_program_;
+};
+
 const void* kUserDataKey = &kUserDataKey;
 
 class UserData : public content::WebContents::Data {
  public:
   UserData(InProcessViewRenderer* ptr) : instance_(ptr) {}
   virtual ~UserData() {
     instance_->WebContentsGone();
   }
 
   static InProcessViewRenderer* GetInstance(content::WebContents* contents) {
@@ skipping 144 matching lines @@
   DCHECK(view_visible_);
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   if (!current_context) {
     LOG(WARNING) << "No current context attached. Skipping composite.";
     return;
   }
 
+  GLStateRestore state_restore;
+
   if (attached_to_window_ && compositor_ && !hardware_initialized_) {
     // TODO(boliu): Actually initialize the compositor GL path.
     hardware_initialized_ = true;
     egl_context_at_init_ = current_context;
   }
 
   if (draw_info->mode == AwDrawGLInfo::kModeProcess)
     return;
 
   if (egl_context_at_init_ != current_context) {
@@ skipping 10 matching lines @@
   transform.Translate(hw_rendering_scroll_.x(), hw_rendering_scroll_.y());
   // TODO(joth): Check return value.
   compositor_->DemandDrawHw(
       gfx::Size(draw_info->width, draw_info->height),
       transform,
       gfx::Rect(draw_info->clip_left,
                 draw_info->clip_top,
                 draw_info->clip_right - draw_info->clip_left,
                 draw_info->clip_bottom - draw_info->clip_top));
 
-  // The GL functor must ensure these are set to zero before returning.
-  // Not setting them leads to graphical artifacts that can affect other apps.
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
   EnsureContinuousInvalidation();
 }
 
 bool InProcessViewRenderer::DrawSW(jobject java_canvas,
                                    const gfx::Rect& clip) {
   bool result = DrawSWInternal(java_canvas, clip);
   EnsureContinuousInvalidation();
   return result;
 }
 
@@ skipping 190 matching lines @@
   // TODO(joth): BrowserViewRendererImpl had a bunch of logic for dpi and page
   // scale here. Determine what if any needs bringing over to this class.
   return CompositeSW(canvas);
 }
 
 bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) {
   return compositor_ && compositor_->DemandDrawSw(canvas);
 }
 
 }  // namespace android_webview