cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

cc/resources/scoped_release_callback.h

Index: cc/resources/scoped_release_callback.h
diff --git a/cc/resources/scoped_release_callback.h b/cc/resources/scoped_release_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..d19c7bffcaeb9f99abd578b862441e47391aec2f
--- /dev/null
+++ b/cc/resources/scoped_release_callback.h
@@ -0,0 +1,44 @@
+// 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_SCOPED_RELEASE_CALLBACK_H_
+#define CC_RESOURCES_SCOPED_RELEASE_CALLBACK_H_
+
+#include "base/move.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/release_callback.h"
+
+namespace cc {
+
+// A ReleaseCallback that can only have one owner. It must have RunAndReset()

[awong, 2013/09/13 07:07:19]

???  As is, can't people just copy ReleaseCallbacks everywhere? If this is such
a hard requirement, would it be sensible to make people return only
ScopedReleaseCallbacks and then somehow hide the ReleaseCallback type?

[danakj, 2013/09/13 17:32:59]

Yes, we have been careful to ensure they are always run once thru other
mechanisms (TextureLayer::MailboxHolder or via code review.
Yes.. but I have two counter examples in the code currently.

1) VideoLayerImpl receives a ReleaseCallback that it runs once for each software
resource. We could just give a vector of Scoped callbacks though.. but that's
just the code as is:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/layers/video_la...

More interesting is:

2) Move only types can't go in containers, so we Leak() the callback inside
ResourceProvider so it can live in the Resource hash map. This is a case where
we want to have a separate "ReleaseCallback" type still, at least for now:
https://codereview.chromium.org/23648014/diff/8001/cc/resources/resource_prov...

But, even without these, how would you envision creating a ScopedReleaseCallback
without first making a Callback and giving it to the constructor?

+// called before it is destroyed.
+class CC_EXPORT ScopedReleaseCallback {
+  MOVE_ONLY_TYPE_FOR_CPP_03(ScopedReleaseCallback, RValue)
+ public:
+  ScopedReleaseCallback();
+  explicit ScopedReleaseCallback(const ReleaseCallback& callback);
+  // This constructor is for Pass().
+  ScopedReleaseCallback(RValue other);  // NOLINT(runtime/explicit)
+  ~ScopedReleaseCallback();
+
+  void RunAndReset(unsigned sync_point, bool is_lost);
+
+  // Move-only emulation, only usable with Pass().
+  ScopedReleaseCallback& operator=(ScopedReleaseCallback rhs);
+
+  ReleaseCallback Leak();
+
+  bool Equals(const ScopedReleaseCallback& other) const {
+    return callback_.Equals(other.callback_);
+  }
+
+  bool IsEmpty() const { return callback_.is_null(); }

[piman, 2013/09/13 06:08:30]

nit: is_null() ? I'm not sure 'empty' qualifies a callback well.

+
+ private:
+  ReleaseCallback callback_;
+};
+
+}  // namespace cc
+
+#endif  // CC_RESOURCES_SCOPED_RELEASE_CALLBACK_H_