Gets rid of chrome being cleared for a moment when keyboard is hidden

chrome/browser/renderer_host/accelerated_surface_container_touch.cc

 // Copyright (c) 2011 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 "chrome/browser/renderer_host/accelerated_surface_container_touch.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xcomposite.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_egl.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/gl/gl_surface_glx.h"
 #include "ui/gfx/transform.h"
 
 namespace {
 
 class AcceleratedSurfaceContainerTouchEGL
     : public AcceleratedSurfaceContainerTouch {
  public:
   AcceleratedSurfaceContainerTouchEGL(ui::CompositorGL* compositor,
                                       const gfx::Size& size,
                                       uint64 surface_handle);
   // TextureGL implementation
   virtual void Draw(const ui::TextureDrawParams& params,
-                    const gfx::Rect& clip_bounds) OVERRIDE;
+                    const gfx::Rect& clip_bounds_in_texture) OVERRIDE;
 
  private:
   ~AcceleratedSurfaceContainerTouchEGL();
 
   void* image_;
   DISALLOW_COPY_AND_ASSIGN(AcceleratedSurfaceContainerTouchEGL);
 };
 
 class AcceleratedSurfaceContainerTouchGLX
     : public AcceleratedSurfaceContainerTouch {
  public:
   AcceleratedSurfaceContainerTouchGLX(ui::CompositorGL* compositor,
                                       const gfx::Size& size,
                                       uint64 surface_handle);
   // TextureGL implementation
   virtual void Draw(const ui::TextureDrawParams& params,
-                    const gfx::Rect& clip_bounds) OVERRIDE;
+                    const gfx::Rect& clip_bounds_in_texture) OVERRIDE;
 
  private:
   ~AcceleratedSurfaceContainerTouchGLX();
 
   XID pixmap_;
   XID glx_pixmap_;
   DISALLOW_COPY_AND_ASSIGN(AcceleratedSurfaceContainerTouchGLX);
 };
 
 class ScopedPtrXFree {
@@ skipping 25 matching lines @@
   glFlush();
 }
 
 AcceleratedSurfaceContainerTouchEGL::~AcceleratedSurfaceContainerTouchEGL() {
   eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), image_);
   glFlush();
 }
 
 void AcceleratedSurfaceContainerTouchEGL::Draw(
     const ui::TextureDrawParams& params,
-    const gfx::Rect& clip_bounds) {
+    const gfx::Rect& clip_bounds_in_texture) {
   DCHECK(compositor_->program_no_swizzle());
 
   ui::TextureDrawParams modified_params = params;
 
   // Texture from GPU is flipped vertically.
   ui::Transform flipped;
   flipped.SetScaleY(-1.0);
   flipped.SetTranslateY(size_.height());
   flipped.ConcatTransform(params.transform);
 
   modified_params.transform = flipped;
 
   DrawInternal(*compositor_->program_no_swizzle(),
                modified_params,
-               clip_bounds);
+               clip_bounds_in_texture);
 }
 
 AcceleratedSurfaceContainerTouchGLX::AcceleratedSurfaceContainerTouchGLX(
     ui::CompositorGL* compositor,
     const gfx::Size& size,
     uint64 surface_handle)
     : AcceleratedSurfaceContainerTouch(compositor, size),
       pixmap_(0),
       glx_pixmap_(0) {
   // Create pixmap from window.
@@ skipping 79 matching lines @@
 AcceleratedSurfaceContainerTouchGLX::~AcceleratedSurfaceContainerTouchGLX() {
   Display* dpy = gfx::GLSurfaceGLX::GetDisplay();
   if (glx_pixmap_)
     glXDestroyGLXPixmap(dpy, glx_pixmap_);
   if (pixmap_)
     XFreePixmap(dpy, pixmap_);
 }
 
 void AcceleratedSurfaceContainerTouchGLX::Draw(
     const ui::TextureDrawParams& params,
-    const gfx::Rect& clip_bounds) {
+    const gfx::Rect& clip_bounds_in_texture) {
   DCHECK(compositor_->program_no_swizzle());
   Display* dpy = gfx::GLSurfaceGLX::GetDisplay();
 
   glBindTexture(GL_TEXTURE_2D, texture_id_);
   glXBindTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
   DrawInternal(*compositor_->program_no_swizzle(),
                params,
-               clip_bounds);
+               clip_bounds_in_texture);
   glXReleaseTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT);
 }
 
 }  // namespace
 
 AcceleratedSurfaceContainerTouch::AcceleratedSurfaceContainerTouch(
     ui::CompositorGL* compositor,
     const gfx::Size& size) :
         TextureGL(compositor, size) {
 }
@@ skipping 18 matching lines @@
       return NULL;
   }
 }
 
 void AcceleratedSurfaceContainerTouch::SetCanvas(
     const SkCanvas& canvas,
     const gfx::Point& origin,
     const gfx::Size& overall_size) {
   NOTREACHED();
 }