Mac: Always use surfaceless mode

content/browser/compositor/buffer_queue.h

 // Copyright 2014 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.
 
 #ifndef CONTENT_BROWSER_COMPOSITOR_BUFFER_QUEUE_H_
 #define CONTENT_BROWSER_COMPOSITOR_BUFFER_QUEUE_H_
 
 #include <queue>
 #include <vector>
 
+#include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/content_export.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace cc {
 class ContextProvider;
 }
 
+namespace gfx {
+class GpuMemoryBuffer;
+}
+
 namespace content {
 
 class BrowserGpuMemoryBufferManager;
 class GLHelper;
 
 // Provides a surface that manages its own buffers, backed by GpuMemoryBuffers
 // created using CHROMIUM_gpu_memory_buffer_image. Double/triple buffering is
 // implemented internally. Doublebuffering occurs if PageFlipComplete is called
 // before the next BindFramebuffer call, otherwise it creates extra buffers.
 class CONTENT_EXPORT BufferQueue {
@@ skipping 15 matching lines @@
 
   void RecreateBuffers();
 
   unsigned int current_texture_id() const { return current_surface_.texture; }
   unsigned int fbo() const { return fbo_; }
 
  private:
   friend class BufferQueueTest;
 
   struct AllocatedSurface {
-    AllocatedSurface() : texture(0), image(0) {}
-    AllocatedSurface(unsigned int texture,
+    AllocatedSurface();
+    AllocatedSurface(scoped_ptr<gfx::GpuMemoryBuffer> buffer,
+                     unsigned int texture,
                      unsigned int image,
-                     const gfx::Rect& rect)
-        : texture(texture), image(image), damage(rect) {}
+                     const gfx::Rect& rect);
+    ~AllocatedSurface();

[ccameron, 2015/10/22 22:16:49]

This is the part where we keep the GMB around while the surface is being tracked
by the browser, so that its IOSurface can be opened when the swap comes back
from the GPU process.

[Ken Russell (switch to Gerrit), 2015/10/23 01:13:13]

I'm not qualified to review this change; suggest danakj@, enne@ or reveman@.

[danakj, 2015/10/23 19:52:08]

Ya reveman or some of the ozone ppls would be good. (Normally buffer queue
changes come with unit tests?)

[alexst (slow to review), 2015/10/23 19:59:10]

This should be fine, the reason we didn't hold onto the reference for the buffer
is that as soon as you attach it to a gl_image, it refs it internally in the GPU
process and since we only ever needed the gl_image for chrome os, we let the
buffer object go. If the original buffer is required for OSX, I see nothing
wrong with that.

+    linked_ptr<gfx::GpuMemoryBuffer> buffer;

[reveman, 2015/10/23 20:44:40]

Can we avoid having these be reference counted?

[ccameron, 2015/10/26 22:28:11]

Yes, but that will require making the various instances of AllocatedSurface be
scoped_ptr, which is a bigger refactor than I want to put into this patch. The
refactor is a good one (in particular, we check |texture| when a null check
would be better, so I'm much more of a fan of the newer version), but it has a
high chance of breaking stuff. I've put a TODO and I'll put up the new patch in
a bit.

I'd prefer to do this via a linked_ptr in the mean time.

     unsigned int texture;
     unsigned int image;
     gfx::Rect damage;  // This is the damage for this frame from the previous.
   };
 
   void FreeAllSurfaces();
 
   void FreeSurface(AllocatedSurface* surface);
 
   // Copy everything that is in |copy_rect|, except for what is in
@@ skipping 23 matching lines @@
   GLHelper* gl_helper_;
   BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager_;
   int surface_id_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_COMPOSITOR_BUFFER_QUEUE_H_