Make software compositing work on Mac.

content/browser/renderer_host/software_frame_manager.h

+// Copyright 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_SOFTWARE_FRAME_MANAGER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_SOFTWARE_FRAME_MANAGER_H_
+
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/shared_memory.h"
+#include "base/memory/weak_ptr.h"
+#include "cc/output/software_frame_data.h"
+#include "cc/resources/single_release_callback.h"
+#include "cc/resources/texture_mailbox.h"
+#include "ui/gfx/size.h"
+
+namespace content {
+class SoftwareFrame;
+class SoftwareFrameMemoryManager;
+
+class SoftwareFrameManagerClient {
+ public:
+  // Called when the memory for the current software frame was freed.
+  virtual void SoftwareFrameWasFreed(
+      uint32 output_surface_id, unsigned frame_id) = 0;
+  // Called immediately after CurrentSoftwareFrameWasFreed if the frame

[piman, 2013/10/22 22:32:48]

nit: "CurrentSoftwareFrameWasFreed" doesn't exist, I assume you meant
"SoftwareFrameWasFreed".

That said, I don't see SoftwareFrameWasFreed being called at all in the
implementation - did I miss it?

Lastly, is it worth having 2 methods? Maybe we can pass a bool in
SoftwareFrameWasFreed? I could imagine the implementation wanting to do
something in SoftwareFrameWasFreed based on whether it was an eviction or not,
but as it is, it has to wait to see whether CurrentSoftwareFrameWasEvicted is
called or not, which is awkward.

[ccameron, 2013/10/23 01:05:58]

Done
It is called in the dtor for SoftwareFrame -- the call is made when the memory
for a frame is actually freed.
There are two separate calls here here.

When we hit memory pressure, we go tell the Client "hey, if you're holding on to
any references to this frame, drop them, so we can free up its memory". The
references, in practice, are textures in the browser compositor. The mechanism
by which this is done is the mailbox destructor callback, ReleaseMailbox, which
has the scoped_refptr to the SoftwareFrame bound in it.

The second call is the one that we make when the memory for the frame is
actually freed. When that call is made, we go tell the Renderer "hey, we're done
with this shared memory now" -- you can free it or scribble on it or whatever.
When we swap frames, this is made when the last reference to the frame being
used is removed. During eviction, this call is made only once all references to
the frame are killed off.

I renamed the "evict" method to "release your references to the software frame"
to disambiguate a bit better, and added comments.

I added a test (EvictVersusFree) to demonstrate this, and to verify that the
callback holds on to the frame until it is ditched (even if there are multiple
intervening swaps).

[piman, 2013/10/23 23:41:40]

Ok, sorry, I had missed that.
Ok, thanks for the explanation. The previous documentation suggested we call
SoftwareFrameWasFreed first, and then CurrentSoftwareFrameWasEvicted. The new
documentation is clearer.

+  // was freed because the FrameMemoryManager requested it be freed.
+  virtual void CurrentSoftwareFrameWasEvicted() = 0;
+};
+
+class SoftwareFrameManager {
+ public:
+  SoftwareFrameManager(base::WeakPtr<SoftwareFrameManagerClient> client);

[piman, 2013/10/22 22:32:48]

nit: explicit

[ccameron, 2013/10/23 01:05:58]

Done.

+  ~SoftwareFrameManager();
+
+  // Swap to a new frame from shared memory. This frame is guaranteed to

[piman, 2013/10/22 22:32:48]

nit: Swaps

[ccameron, 2013/10/23 01:05:58]

Done.

+  // not be evicted until SwapToNewFrameComplete is called.
+  bool SwapToNewFrame(
+      uint32 output_surface_id,
+      const cc::SoftwareFrameData* frame_data,
+      float frame_device_scale_factor,
+      base::ProcessHandle process_handle);
+  void SwapToNewFrameComplete(bool visible);
+  void SetVisibility(bool visible);
+  bool HasCurrentFrame() const;
+  void DiscardCurrentFrame();
+  void GetCurrentFrameMailbox(
+      cc::TextureMailbox* mailbox,
+      scoped_ptr<cc::SingleReleaseCallback>* callback);
+  const void* GetCurrentFramePixels() const;
+  gfx::Size GetCurrentFrameSizeInPixels() const;
+  gfx::Size GetCurrentFrameSizeInDIP() const;
+
+  // Called by SoftwareFrameMemoryManager to demand that the current frame
+  // be evicted.

[piman, 2013/10/22 22:32:48]

nit: maybe make it private and make SoftwareFrameMemoryManager a friend

[ccameron, 2013/10/23 01:05:58]

Done.

+  void EvictCurrentFrame();
+
+ private:
+  base::WeakPtr<SoftwareFrameManagerClient> client_;
+
+  // This holds the current software framebuffer.
+  scoped_refptr<SoftwareFrame> current_frame_;

[piman, 2013/10/22 22:32:48]

nit: DISALLOW_COPY_AND_ASSIGN

[ccameron, 2013/10/23 01:05:58]

Done.

+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_SOFTWARE_FRAME_MANAGER_H_