CopyOutputResult must have a working release callback when received over mojo

cc/resources/single_release_callback.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_SINGLE_RELEASE_CALLBACK_H_
 #define CC_RESOURCES_SINGLE_RELEASE_CALLBACK_H_
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "cc/base/cc_export.h"
 #include "cc/resources/release_callback.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+
+namespace mojo {
+template <class T>
+class InterfacePtr;
+}
 
 namespace cc {
 
+namespace mojom {
+class SingleReleaseCallbackDataView;
+class TextureMailboxReleaser;
+typedef mojo::InterfacePtr<TextureMailboxReleaser> TextureMailboxReleaserPtr;
+}
+
 class CC_EXPORT SingleReleaseCallback {
+  class PtrHolder {
+   public:
+    virtual ~PtrHolder() {}
+    virtual mojom::TextureMailboxReleaserPtr TakePtr() = 0;
+    virtual void Release(const gpu::SyncToken& sync_token, bool is_lost) = 0;
+  };
+
+  template <class T>
+  class PtrHolderImpl : public PtrHolder {
+   public:
+    explicit PtrHolderImpl(T ptr) : ptr_(std::move(ptr)) {}
+    T TakePtr() { return std::move(ptr_); }
+    void Release(const gpu::SyncToken& sync_token, bool is_lost) override {
+      ptr_->Release(sync_token, is_lost);
+    }
+
+   private:
+    T ptr_;
+  };
+
  public:
   static std::unique_ptr<SingleReleaseCallback> Create(
       const ReleaseCallback& cb) {
     return base::WrapUnique(new SingleReleaseCallback(cb));
   }
 
+  template <class T>
+  static std::unique_ptr<SingleReleaseCallback> Create(T ptr) {
+    auto ptr_holder = base::MakeUnique<PtrHolderImpl<T>>(std::move(ptr));
+    return base::WrapUnique(new SingleReleaseCallback(std::move(ptr_holder)));
+  }
+
   ~SingleReleaseCallback();
 
   void Run(const gpu::SyncToken& sync_token, bool is_lost);
 
  private:
+  friend struct mojo::StructTraits<mojom::SingleReleaseCallbackDataView,
+                                   std::unique_ptr<SingleReleaseCallback>>;
+
   explicit SingleReleaseCallback(const ReleaseCallback& callback);
+  explicit SingleReleaseCallback(std::unique_ptr<PtrHolder> ptr_holder);
 
   ReleaseCallback callback_;
+  std::unique_ptr<PtrHolder> ptr_holder_;
+
+  DISALLOW_COPY_AND_ASSIGN(SingleReleaseCallback);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_SINGLE_RELEASE_CALLBACK_H_