Replace WGC3D visibility extension with resource_usage extension. [Part 2 of 3]

content/common/gpu/image_transport_surface_linux.cc

 // Copyright (c) 2012 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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/common/gpu/image_transport_surface.h"
 
 // This conflicts with the defines in Xlib.h and must come first.
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 57 matching lines @@
   // gfx::GLSurface implementation
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
   virtual std::string GetExtensions() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
   virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
-  virtual void SetVisible(bool visible) OVERRIDE;
+  virtual void SetResourceUsage(ResourceUsage resourceUsage) OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation
   virtual void OnNewSurfaceACK(
       uint64 surface_id, TransportDIB::Handle surface_handle) OVERRIDE;
   virtual void OnBuffersSwappedACK() OVERRIDE;
   virtual void OnPostSubBufferACK() OVERRIDE;
   virtual void OnResizeViewACK() OVERRIDE;
   virtual void OnResize(gfx::Size size) OVERRIDE;
 
@@ skipping 28 matching lines @@
                            int32 command_buffer_id);
 
   // gfx::GLSurface implementation:
   virtual bool Initialize() OVERRIDE;
   virtual void Destroy() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
   virtual std::string GetExtensions();
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool OnMakeCurrent(gfx::GLContext* context) OVERRIDE;
-  virtual void SetVisible(bool visible) OVERRIDE;
+  virtual void SetResourceUsage(ResourceUsage resourceUsage) OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation:
   virtual void OnNewSurfaceACK(
       uint64 surface_id, TransportDIB::Handle surface_handle) OVERRIDE;
   virtual void OnBuffersSwappedACK() OVERRIDE;
   virtual void OnPostSubBufferACK() OVERRIDE;
   virtual void OnResizeViewACK() OVERRIDE;
   virtual void OnResize(gfx::Size size) OVERRIDE;
 
@@ skipping 167 matching lines @@
   }
 
   made_current_ = true;
   return true;
 }
 
 unsigned int EGLImageTransportSurface::GetBackingFrameBufferObject() {
   return fbo_id_;
 }
 
-void EGLImageTransportSurface::SetVisible(bool visible) {
-  if (!visible && back_surface_.get() && front_surface_.get()) {
-    ReleaseSurface(&back_surface_);
-  } else if (visible && !back_surface_.get() && front_surface_.get()) {
-    // Leverage the OnResize hook because it does exactly what we want
-    OnResize(front_surface_->size());
+void EGLImageTransportSurface::SetResourceUsage(ResourceUsage resourceUsage) {
+  switch (resourceUsage) {
+    case RESOURCE_USAGE_FULL:
+      if (!back_surface_.get() && front_surface_.get()) {
+        // Leverage the OnResize hook because it does exactly what we want
+        OnResize(front_surface_->size());
+      }
+      break;
+    case RESOURCE_USAGE_LESS:
+      if (back_surface_.get() && front_surface_.get())
+        ReleaseSurface(&back_surface_);
+      break;
+    case RESOURCE_USAGE_NONE:
+      // TODO(mmocny): drop all the buffers
+      break;
   }
 }
 
 void EGLImageTransportSurface::ReleaseSurface(
     scoped_refptr<EGLAcceleratedSurface>* surface) {
   if (surface->get()) {
     GpuHostMsg_AcceleratedSurfaceRelease_Params params;
     params.identifier = (*surface)->pixmap();
     helper_->SendAcceleratedSurfaceRelease(params);
     *surface = NULL;
@@ skipping 171 matching lines @@
 }
 
 void GLXImageTransportSurface::ReleaseSurface() {
   DCHECK(bound_);
   GpuHostMsg_AcceleratedSurfaceRelease_Params params;
   params.identifier = window_;
   helper_->SendAcceleratedSurfaceRelease(params);
   bound_ = false;
 }
 
-void GLXImageTransportSurface::SetVisible(bool visible) {
+void GLXImageTransportSurface::SetResourceUsage(ResourceUsage resourceUsage) {
   Display* dpy = static_cast<Display*>(GetDisplay());
-  if (!visible) {
-    XResizeWindow(dpy, window_, 1, 1);
-  } else {
-    XResizeWindow(dpy, window_, size_.width(), size_.height());
-    needs_resize_ = true;
+  switch (resourceUsage) {
+    case RESOURCE_USAGE_FULL:
+      XResizeWindow(dpy, window_, size_.width(), size_.height());
+      needs_resize_ = true;
+      break;
+    case RESOURCE_USAGE_LESS:
+      XResizeWindow(dpy, window_, 1, 1);
+      break;
+    case RESOURCE_USAGE_NONE:
+      // TODO(mmocny): drop all the buffers
+      break;
   }
   glXWaitX();
 }
 
 void GLXImageTransportSurface::OnResize(gfx::Size size) {
   TRACE_EVENT0("gpu", "GLXImageTransportSurface::OnResize");
   size_ = size;
 
   Display* dpy = static_cast<Display*>(GetDisplay());
   XResizeWindow(dpy, window_, size_.width(), size_.height());
@@ skipping 304 matching lines @@
                                                  command_buffer_id,
                                                  surface.get());
 #endif
   if (surface->Initialize())
     return surface;
   else
     return NULL;
 }
 
 #endif  // defined(USE_GPU)