[OnionSoup] Moving VR service from content to Blink

third_party/WebKit/Source/platform/threading/BindForMojo.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 BindForMojo_h
 #define BindForMojo_h
 
 #include "base/bind.h"
 #include "mojo/public/cpp/bindings/callback.h"
 
 // This file provides limited access to base::Bind() function. base::Bind()
 // could be dangerous if it's used across threads, so we don't want to allow
 // general use of base::Bind().
 // See also "platform/ThreadSafeFunctional.h".
 
 namespace blink {
 
 // Binds an instance of a class to its member function. Does not bind anything
 // else.
 template <typename Class, typename ReturnType, typename... Args>
 mojo::Callback<ReturnType(Args...)>
 sameThreadBindForMojo(ReturnType (Class::*method)(Args...), Class* instance)
 {
     return base::Bind(method, base::Unretained(instance));
 }
 
+template <typename Class, typename ReturnType, typename BoundArgs, typename... Args>
+mojo::Callback<ReturnType(Args...)>
+sameThreadBindForMojoWithBoundArgs(ReturnType (Class::*method)(BoundArgs*, Args...), Class* instance, BoundArgs* bound)
+{
+    return base::Bind(method, base::Unretained(instance), base::Unretained(bound));

[Yuki, 2016/03/22 07:15:03]

In general, this is not a good idea because it's not always true that |bound|
will be kept alive until the callback function gets called back.  See the
original use case, the caller of base::Bind specifies how to control the
lifetime of |bound|, such as Unretained, Owned, etc.

If possible, you'd better to avoid binding the arguments other than |this| until
Blink gets to better support the callback binding.

[RaviKasibhatla, 2016/03/23 15:20:50]

In GetDevices, the original Web callback is being stored in the
VRGetDevicesRequest object created before binding the mojo::Callback.
In GetSensorState, we receive the WebHMDSensorState variable which needs to be
filled back in the mojo::Callback. So, for both the mojo::Callback binding calls
in vr_dispatcher, we do need to bound objects other than 'this' pointer. Even in
the original code, the state and request_id are binded in the callback.

Regarding the lifetime of the bounded args, atleast in both the calling
scenarios currently, the binded objects will be alive.  I marked bind args as
Unretained since the original code was binding them in same scope.
But if needed, to safeguard to the lifetime of bound objects, I can mark them as
"Owned", so that they are not deleted during the callback lifetime?

[Yuki, 2016/03/25 09:49:04]

I'm talking about not only VRGetDevicesRequest's case but also general cases. 
Other services will use this utility function.  How can we guarantee that those
services are okay with base::Unretained()?  In general, it should be specified
by the callers.

Having said that, we wouldn't want to expose uses of base::Unretained outside
this directory.

Options in my mind are:
1) Rename the function to sameThreadBindForMojoWithUnretainedArgs so that it's
clear that it's caller's duty to keep the args alive.
2) Do not bind the |state|.  Supposing VRDispatcher does not support
multi-thread accesses, you can always store the resulting |state| into a member
variable.

[haraken, 2016/03/25 09:56:36]

Dcheng and Dana are working on it
(https://bugs.chromium.org/p/chromium/issues/detail?id=597856).

+}
+
 } // namespace blink
 
 #endif // BindForMojo_h