Remove threading from RendererGpuVideoAcceleratorFactories

media/base/bind_to_loop.h

 // This file was GENERATED by command:
 //     pump.py bind_to_loop.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 // Copyright (c) 2012 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 MEDIA_BASE_BIND_TO_LOOP_H_
 #define MEDIA_BASE_BIND_TO_LOOP_H_
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/synchronization/waitable_event.h"
 
 // This is a helper utility for base::Bind()ing callbacks on to particular
 // MessageLoops.  A typical use is when |a| (of class |A|) wants to hand a
 // callback such as base::Bind(&A::AMethod, a) to |b|, but needs to ensure that
 // when |b| executes the callback, it does so on a particular MessageLoop.
 //
 // Typical usage: request to be called back on the current thread:
 // other->StartAsyncProcessAndCallMeBack(
 //    media::BindToLoop(MessageLoopProxy::current(),
 //                      base::Bind(&MyClass::MyMethod, this)));
 //
-// Note that like base::Bind(), BindToLoop() can't bind non-constant references,
-// and that *unlike* base::Bind(), BindToLoop() makes copies of its arguments,
-// and thus can't be used with arrays.
+// For synchronous usage, where the callback needs to be executed on another
+// MessageLoop, but the calling thread should block until the callback has been
+// completed, there is BindToLoopSync(), as below:
+//
+// Typical usage: make a request to another thread, and wait for it:
+// do_something_callback =
+//   media::BindToLoopSync(other_message_loop, &OtherClass::DoRequest, other);
+// // ...
+// do_something_callback.Run();  // will block until completion
+//
+// Note that like base::Bind(), BindToLoop() and BindToLoopSync() can't bind
+// non-constant references, and that *unlike* base::Bind(), BindToLoop*() makes
+// copies of its arguments, and thus can't be used with arrays.
 
 namespace media {
 
 // Mimic base::internal::CallbackForward, replacing p.Pass() with
 // base::Passed(&p) to account for the extra layer of indirection.
 namespace internal {
 template <typename T>
 T& TrampolineForward(T& t) { return t; }
 
 template <typename T>
 base::internal::PassedWrapper<scoped_ptr<T> > TrampolineForward(
     scoped_ptr<T>& p) { return base::Passed(&p); }
 
 template <typename T, typename R>
 base::internal::PassedWrapper<scoped_ptr_malloc<T, R> > TrampolineForward(
     scoped_ptr_malloc<T, R>& p) { return base::Passed(&p); }
 
 template <typename T>
 base::internal::PassedWrapper<ScopedVector<T> > TrampolineForward(
     ScopedVector<T>& p) { return base::Passed(&p); }
 
 template <typename T> struct TrampolineHelper;
 
+// Caller helper to call a base::Closure synchronously
+void TrampolineSyncCaller(const base::Closure& closure,
+                          base::WaitableEvent* waiter);
+
 template <>
 struct TrampolineHelper<void()> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void()>& cb) {
     loop->PostTask(FROM_HERE, base::Bind(cb));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void()>& cb) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1>
 struct TrampolineHelper<void(A1)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1)>& cb, A1 a1) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1)>& cb, A1 a1) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1, typename A2>
 struct TrampolineHelper<void(A1, A2)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1, A2)>& cb, A1 a1, A2 a2) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1),
         internal::TrampolineForward(a2)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1, A2)>& cb, A1 a1, A2 a2) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1),
+                internal::TrampolineForward(a2)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1, typename A2, typename A3>
 struct TrampolineHelper<void(A1, A2, A3)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1, A2, A3)>& cb, A1 a1, A2 a2, A3 a3) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1),
         internal::TrampolineForward(a2), internal::TrampolineForward(a3)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1, A2, A3)>& cb, A1 a1, A2 a2, A3 a3) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1),
+                internal::TrampolineForward(a2),
+                internal::TrampolineForward(a3)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1, typename A2, typename A3, typename A4>
 struct TrampolineHelper<void(A1, A2, A3, A4)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1, A2, A3, A4)>& cb, A1 a1, A2 a2, A3 a3,
           A4 a4) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1),
         internal::TrampolineForward(a2), internal::TrampolineForward(a3),
         internal::TrampolineForward(a4)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1, A2, A3, A4)>& cb, A1 a1, A2 a2, A3 a3,
+          A4 a4) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1),
+                internal::TrampolineForward(a2),
+                internal::TrampolineForward(a3),
+                internal::TrampolineForward(a4)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1, typename A2, typename A3, typename A4, typename A5>
 struct TrampolineHelper<void(A1, A2, A3, A4, A5)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1, A2, A3, A4, A5)>& cb, A1 a1, A2 a2, A3 a3,
           A4 a4, A5 a5) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1),
         internal::TrampolineForward(a2), internal::TrampolineForward(a3),
         internal::TrampolineForward(a4), internal::TrampolineForward(a5)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1, A2, A3, A4, A5)>& cb, A1 a1, A2 a2, A3 a3,
+          A4 a4, A5 a5) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1),
+                internal::TrampolineForward(a2),
+                internal::TrampolineForward(a3),
+                internal::TrampolineForward(a4),
+                internal::TrampolineForward(a5)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1, typename A2, typename A3, typename A4, typename A5,
     typename A6>
 struct TrampolineHelper<void(A1, A2, A3, A4, A5, A6)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1, A2, A3, A4, A5, A6)>& cb, A1 a1, A2 a2,
           A3 a3, A4 a4, A5 a5, A6 a6) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1),
         internal::TrampolineForward(a2), internal::TrampolineForward(a3),
         internal::TrampolineForward(a4), internal::TrampolineForward(a5),
         internal::TrampolineForward(a6)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1, A2, A3, A4, A5, A6)>& cb, A1 a1, A2 a2,
+          A3 a3, A4 a4, A5 a5, A6 a6) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1),
+                internal::TrampolineForward(a2),
+                internal::TrampolineForward(a3),
+                internal::TrampolineForward(a4),
+                internal::TrampolineForward(a5),
+                internal::TrampolineForward(a6)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 template <typename A1, typename A2, typename A3, typename A4, typename A5,
     typename A6, typename A7>
 struct TrampolineHelper<void(A1, A2, A3, A4, A5, A6, A7)> {
   static void Run(
       const scoped_refptr<base::MessageLoopProxy>& loop,
       const base::Callback<void(A1, A2, A3, A4, A5, A6, A7)>& cb, A1 a1, A2 a2,
           A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
     loop->PostTask(FROM_HERE, base::Bind(cb, internal::TrampolineForward(a1),
         internal::TrampolineForward(a2), internal::TrampolineForward(a3),
         internal::TrampolineForward(a4), internal::TrampolineForward(a5),
         internal::TrampolineForward(a6), internal::TrampolineForward(a7)));
   }
+  static void RunSync(
+      const scoped_refptr<base::MessageLoopProxy>& loop,
+      const base::Callback<void(A1, A2, A3, A4, A5, A6, A7)>& cb, A1 a1, A2 a2,
+          A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
+    DCHECK(!loop->BelongsToCurrentThread());
+    base::WaitableEvent waiter(false, false);
+    loop->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &TrampolineSyncCaller,
+            base::Bind(cb, internal::TrampolineForward(a1),
+                internal::TrampolineForward(a2),
+                internal::TrampolineForward(a3),
+                internal::TrampolineForward(a4),
+                internal::TrampolineForward(a5),
+                internal::TrampolineForward(a6),
+                internal::TrampolineForward(a7)),
+            &waiter));
+    waiter.Wait();
+  }
 };
 
 
 }  // namespace internal
 
 template<typename T>
 static base::Callback<T> BindToLoop(
     const scoped_refptr<base::MessageLoopProxy>& loop,
     const base::Callback<T>& cb) {
   return base::Bind(&internal::TrampolineHelper<T>::Run, loop, cb);
 }
 
 template<typename T>
+static base::Callback<T> BindToLoopSync(

[jam, 2013/10/28 20:11:08]

I'm concerned about this. This makes it easy for code to block one message loop
on another, which is an anti-pattern. I guess if a background thread is blocked
on another one, that may be ok. But what guarantee do we have that people won't
use this on the UI or IO threads (in the browser) or on the main renderer
thread?

I'm also concerned that we have this parallel base utilities for bind stuff.
Having multiple places to look for base-y things seems confusing and will lead
to duplication.

[sheu, 2013/10/28 20:32:58]

There's no guarantee, other than a general exhortation not to.  Is this danger
sufficient to make BindToLoopSync() something that Should Not Be Done?
That depends on the discussion previously on whether this has the approvals to
be put in base/.  It probably could, but I think that should be a separate
change where BindToLoop() goes into base/ simultaneously.

[jam, 2013/10/28 20:43:25]

If there's one thing I've learnt on Chrome, it's introducing a way to shoot
yourself in the foot will be abused much faster than could ever be expected.

So this is why I'm opposed to have a generic functionality to block one thread
on another. Or, at the very least, we should only do this after we have a
mechanism to enable it only for specific (background) threads, and to have a way
that ensures that this never gets allowed for main/IO threads.

+    const scoped_refptr<base::MessageLoopProxy>& loop,
+    const base::Callback<T>& cb) {
+  return base::Bind(&internal::TrampolineHelper<T>::RunSync, loop, cb);
+}
+
+template<typename T>
 static base::Callback<T> BindToCurrentLoop(
     const base::Callback<T>& cb) {
   return BindToLoop(base::MessageLoopProxy::current(), cb);
 }
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_BIND_TO_LOOP_H_