Turned on PbufferImageTransportSurface as default image transport for vista and win 7 (not XP).

content/common/gpu/image_transport_surface_win.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.
 
 #if defined(ENABLE_GPU)
 
 #include "content/common/gpu/image_transport_surface.h"
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/win/windows_version.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/public/common/content_switches.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_egl.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace {
 
 // We are backed by an Pbuffer offscreen surface through which ANGLE provides
 // a handle to the corresponding render target texture through an extension.
 class PbufferImageTransportSurface
     : public gfx::GLSurfaceAdapter,
       public ImageTransportSurface,
       public base::SupportsWeakPtr<PbufferImageTransportSurface> {
  public:
   PbufferImageTransportSurface(GpuChannelManager* manager,
                                int32 render_view_id,
                                int32 renderer_id,
                                int32 command_buffer_id);
 
   // 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 void SetVisible(bool visible) OVERRIDE;
 
  protected:
   // ImageTransportSurface implementation
   virtual void OnNewSurfaceACK(uint64 surface_id,
                                TransportDIB::Handle shm_handle) OVERRIDE;
   virtual void OnBuffersSwappedACK() OVERRIDE;
   virtual void OnPostSubBufferACK() OVERRIDE;
   virtual void OnResizeViewACK() OVERRIDE;
   virtual void OnResize(gfx::Size size) OVERRIDE;
 
  private:
   virtual ~PbufferImageTransportSurface();
   void SendBuffersSwapped();
 
+  // Whether the surface is currently visible.
+  bool is_visible_;
+
+  // Size to resize to when the surface becomes visible.
+  gfx::Size visible_size_;
+
   scoped_ptr<ImageTransportHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(PbufferImageTransportSurface);
 };
 
 PbufferImageTransportSurface::PbufferImageTransportSurface(
     GpuChannelManager* manager,
     int32 render_view_id,
     int32 renderer_id,
     int32 command_buffer_id)
         : GLSurfaceAdapter(new gfx::PbufferGLSurfaceEGL(false,
-                                                        gfx::Size(1, 1))) {
+                                                        gfx::Size(1, 1))),
+          is_visible_(true) {
   helper_.reset(new ImageTransportHelper(this,
                                          manager,
                                          render_view_id,
                                          renderer_id,
                                          command_buffer_id,
                                          gfx::kNullPluginWindow));
 }
 
 PbufferImageTransportSurface::~PbufferImageTransportSurface() {
   Destroy();
@@ skipping 32 matching lines @@
 
   return true;
 }
 
 bool PbufferImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   NOTREACHED();
   return false;
 }
 
+void PbufferImageTransportSurface::SetVisible(bool visible) {
+  if (visible == is_visible_)
+    return;
+
+  is_visible_ = visible;
+
+  if (visible)
+    Resize(visible_size_);
+  else
+    Resize(gfx::Size(1, 1));
+}
+
 std::string PbufferImageTransportSurface::GetExtensions() {
   std::string extensions = gfx::GLSurface::GetExtensions();
   extensions += extensions.empty() ? "" : " ";
   extensions += "GL_CHROMIUM_front_buffer_cached";
   return extensions;
 }
 
 void PbufferImageTransportSurface::SendBuffersSwapped() {
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_id = reinterpret_cast<int64>(GetShareHandle());
@@ skipping 15 matching lines @@
     uint64 surface_id,
     TransportDIB::Handle shm_handle) {
   NOTREACHED();
 }
 
 void PbufferImageTransportSurface::OnResizeViewACK() {
   NOTREACHED();
 }
 
 void PbufferImageTransportSurface::OnResize(gfx::Size size) {
-  Resize(size);
+  if (is_visible_)
+    Resize(size);
+
+  visible_size_ = size;
 }
 
 }  // namespace anonymous
 
 // static
 scoped_refptr<gfx::GLSurface> ImageTransportSurface::CreateSurface(
     GpuChannelManager* manager,
     int32 render_view_id,
     int32 renderer_id,
     int32 command_buffer_id,
     gfx::PluginWindowHandle handle) {
   scoped_refptr<gfx::GLSurface> surface;
 
   base::win::OSInfo* os_info = base::win::OSInfo::GetInstance();
 
-  // TODO(apatrick): Enable this once it has settled in the tree.
-  if (false && gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
-      os_info->version() >= base::win::VERSION_VISTA) {
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
+      os_info->version() >= base::win::VERSION_VISTA &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableImageTransportSurface)) {
     surface = new PbufferImageTransportSurface(manager,
                                                render_view_id,
                                                renderer_id,
                                                command_buffer_id);
   } else {
     surface = gfx::GLSurface::CreateViewGLSurface(false, handle);
     if (!surface.get())
       return NULL;
 
     surface = new PassThroughImageTransportSurface(manager,
                                                    render_view_id,
                                                    renderer_id,
                                                    command_buffer_id,
                                                    surface.get());
   }
 
   if (surface->Initialize())
     return surface;
   else
     return NULL;
 }
 
 #endif  // ENABLE_GPU