Remove setErrorMessageCallback from WebGraphicsContext3D.

third_party/WebKit/public/platform/functional/WebFunction.h

 // Copyright 2016 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 WebClosure_h
-#define WebClosure_h
+#ifndef WebFunction_h
+#define WebFunction_h
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "public/platform/WebCommon.h"
 
 #include <memory>
 #include <utility>
 
 #if BLINK_IMPLEMENTATION
 #include "wtf/Functional.h"
 #else
 #include "base/logging.h"
 #endif
 
 namespace blink {
 
+template <typename...>
+class WebFunction;
+
 // Conversion from WTF closures to base closures to pass a callback out of
 // blink.
-class WebClosure {
+template <typename R, typename... Args>
+class WebFunction<R(Args...)> {
+private:
+#if BLINK_IMPLEMENTATION
+    using WTFFunction = WTF::Function<R(Args...), WTF::SameThreadAffinity>;
+#endif
+
 public:
 #if BLINK_IMPLEMENTATION
-    WebClosure() {}
+    WebFunction()
+    {
+    }
 
-    explicit WebClosure(PassOwnPtr<SameThreadClosure> c)
+    explicit WebFunction(PassOwnPtr<WTFFunction> c)
     {
-        m_closure = base::Bind(&RunAndDelete, base::Passed(base::WrapUnique(c.leakPtr())));
+        m_callback = base::Bind(&RunAndDelete<R, Args...>, base::Passed(base::WrapUnique(c.leakPtr())));

[danakj, 2016/04/12 21:42:16]

A problem came up in the webgl tests. Using Passed here means the WTF::Function
is destroyed when m_callback is Run(). But we may call the callback more than
once, causing a crash.

Instead, I made base::Callback own the WTF::Function, so they share a lifetime,
and Run() can be used more than once.

     }
 #endif
 
-    // TODO(danakj): These could be =default with MSVC 2015.
-    WebClosure(WebClosure&& other) { *this = std::move(other); }
-    WebClosure& operator=(WebClosure&& other)
+    WebFunction(WebFunction&& other)
+    {
+        *this = std::move(other);
+    }
+    WebFunction& operator=(WebFunction&& other)
     {
 #if DCHECK_IS_ON()
         m_haveClosure = other.m_haveClosure;
         other.m_haveClosure = false;
 #endif
-        m_closure = std::move(other.m_closure);
+        m_callback = std::move(other.m_callback);
         return *this;
     }
 
 #if !BLINK_IMPLEMENTATION
     // TODO(danakj): This could be rvalue-ref-qualified.
-    base::Closure TakeBaseClosure()
+    base::Callback<R(Args...)> TakeBaseCallback()
     {
 #if DCHECK_IS_ON()
         // Don't call this more than once!
         DCHECK(m_haveClosure);
         m_haveClosure = false;
 #endif
-        return std::move(m_closure);
+        return std::move(m_callback);
     }
 #endif
 
 private:
 #if BLINK_IMPLEMENTATION
-    static void RunAndDelete(std::unique_ptr<SameThreadClosure> c) { (*c)(); }
+    template <typename RunR, typename... RunArgs>
+    static RunR RunAndDelete(std::unique_ptr<WTFFunction> c, RunArgs... args)
+    {
+        return (*c)(std::forward<RunArgs>(args)...);
+    }
 #endif
 
 #if DCHECK_IS_ON()
     bool m_haveClosure = true;
 #endif
-    base::Closure m_closure;
+    base::Callback<R(Args...)> m_callback;
 
-    DISALLOW_COPY_AND_ASSIGN(WebClosure);
+    DISALLOW_COPY_AND_ASSIGN(WebFunction);
 };
 
+using WebClosure = WebFunction<void()>;
+
 } // namespace blink
 
 #endif // WebClosure_h