[Aura] Added Support for rendering software compositor frames as cc::TextureLayers.

cc/resources/texture_mailbox.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 CC_RESOURCES_TEXTURE_MAILBOX_H_
 #define CC_RESOURCES_TEXTURE_MAILBOX_H_
 
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/memory/shared_memory.h"
 #include "cc/base/cc_export.h"
 #include "gpu/command_buffer/common/mailbox.h"
+#include "ui/gfx/size.h"
 
 namespace cc {
 
 class CC_EXPORT TextureMailbox {

[danakj, 2013/05/23 15:34:33]

Add a TODO here to rename this class please.

[slavi, 2013/05/28 18:55:13]

Done.

  public:
   typedef base::Callback<void(unsigned sync_point,

[danakj, 2013/05/23 15:34:33]

The values on this callback don't really make sense for software.

What if we have two callbacks, a ReleaseTextureCallback and a
ReleaseSharedMemoryCallback?

Then we could avoid exposing the callback directly from this class, ie. remove
|callback()|, and add some methods to fire the appropriate callbacks
RunReleaseTextureCallback(unsigned,bool) and
RunReleaseSharedMemoryCallback(void). We can DCHECK in these methods that we're
calling the right method for the data in the TextureMailbox.

WDYT? Would that clean things up for make them more complicated?

                               bool lost_resource)> ReleaseCallback;
   TextureMailbox();
   TextureMailbox(const std::string& mailbox_name,
                  const ReleaseCallback& callback);
   TextureMailbox(const gpu::Mailbox& mailbox_name,
                  const ReleaseCallback& callback);
   TextureMailbox(const gpu::Mailbox& mailbox_name,
                  const ReleaseCallback& callback,
                  unsigned sync_point);
   TextureMailbox(const gpu::Mailbox& mailbox_name,
                  const ReleaseCallback& callback,
                  unsigned texture_target,
                  unsigned sync_point);
+  TextureMailbox(base::SharedMemoryHandle handle,
+                 gfx::Size size,

[danakj, 2013/05/23 15:34:33]

For textures we always pass along the size outside of this class right now.
Would it be nice to be consistent here and do the same for software bitmaps?
It's a bit odd that this class holds a size in some modes and not in others.

+                 const ReleaseCallback& callback);
 
   ~TextureMailbox();
 
+  bool IsValid() const { return IsTexture() || IsSharedMemory(); }
+  bool IsTexture() const { return !name_.IsZero(); }
+  bool IsSharedMemory() const {
+    return base::SharedMemory::IsHandleValid(handle_);
+  }
+
+  bool Equals(const gpu::Mailbox&) const;

[danakj, 2013/05/23 15:34:33]

This is the wrong name for this method now. How about Contains()?

[slavi, 2013/05/28 18:55:13]

Done.

+  bool Equals(base::SharedMemoryHandle handle) const;

[danakj, 2013/05/23 15:34:33]

Same here

[slavi, 2013/05/28 18:55:13]

Done.

+  bool Equals(const TextureMailbox&) const;
+
   const ReleaseCallback& callback() const { return callback_; }
   const int8* data() const { return name_.name; }
-  bool Equals(const gpu::Mailbox&) const;
-  bool Equals(const TextureMailbox&) const;
-  bool IsEmpty() const;
   const gpu::Mailbox& name() const { return name_; }

[danakj, 2013/05/23 15:34:33]

I think I'd like to see all the gpu::Mailbox related methods/variables here
moved to another class, and have a pointer+getter method on this class for
accessing them.

Similar for the SharedMemory related stuff.

But that can be done in a followup, maybe at the time we rename this class.

[slavi, 2013/05/28 18:55:13]

Let's do that on a second pass when this guy gets renames.

   void ResetSyncPoint() { sync_point_ = 0; }
   void RunReleaseCallback(unsigned sync_point, bool lost_resource) const;
   void SetName(const gpu::Mailbox&);
   unsigned target() const { return target_; }
   unsigned sync_point() const { return sync_point_; }
 
+  void SetHandle(base::SharedMemoryHandle handle, gfx::Size size);
+  base::SharedMemoryHandle handle() const { return handle_; }
+  gfx::Size size() const { return size_; }
+
  private:
   gpu::Mailbox name_;
   ReleaseCallback callback_;
   unsigned target_;
   unsigned sync_point_;
+  base::SharedMemoryHandle handle_;
+  gfx::Size size_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TEXTURE_MAILBOX_H_