Test using a global, replacable TaskQueueImpl factory.

webrtc/rtc_base/task_queue_impl_factory.cc

Index: webrtc/rtc_base/task_queue_impl_factory.cc
diff --git a/webrtc/rtc_base/task_queue_impl_factory.cc b/webrtc/rtc_base/task_queue_impl_factory.cc
new file mode 100644
index 0000000000000000000000000000000000000000..433da0cb6d3603e787879bc7aeb074babe6a167a
--- /dev/null
+++ b/webrtc/rtc_base/task_queue_impl_factory.cc
@@ -0,0 +1,39 @@
+/*
+ *  Copyright 2017 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <webrtc/rtc_base/task_queue_impl_factory.h>
+
+namespace rtc {
+
+// TODO(perkj): now!! Do we have a way to lazy instantiate ? OnceInit...
+static TaskQueueImplFactory* taskqueue_factory = nullptr;
+static rtc::CriticalSection set_lock;
+
+// Sets the factory to be used by this process. May only be called once
+// before any TaskQueues are created.
+// static
+void TaskQueueImplFactory::Set(TaskQueueImplFactory* factory) {

[kwiberg-webrtc, 2017/08/21 09:21:55]

Is it really a good idea for Set() to not take ownership of the factory? It
would seem safer for Set() to take a unique_ptr, and then explicitly leak the
factory by storing it in the static raw pointer on line 16. (And document that
this is what Set() does!)

Another alternative would be to let the factory be a function pointer instead of
an interface. That way, there is no per-instance state, and storing it in a raw
pointer becomes unproblematic. It doesn't look like you really need any state...

+  rtc::CritScope lock(&set_lock);
+  // TODO(perkj): if OnceInit exist... DOn't allow someone to call Set again.

[nisse-webrtc, 2017/08/18 11:45:45]

If you can put a static variable in a single method, its initializer will be run
only once and (given recent enough C++), in a threadsafe manner.

Say, a private static method like

TaskQueueImplFactory*
Magic(TaskQueueFactory *init) {
  static TaskQueueFactory *the_factory =
    init ? init : new TaskQueueLibEventFactory();
  return the_factory;
}

Get() {
  return Magic(nullptr);
}

Set(TaskQueueImplFactory* init) {
  RTC_CHECK(init);
  RTC_CHECK_EQ(GetMagic(init), init);
}

This has the unintended effect of allowing multiple Set as long as they all pass
the same factory pointer, but I guess that's ok.

+  if (taskqueue_factory)
+    return;

[kwiberg-webrtc, 2017/08/21 09:21:55]

If the contract is that you're only allowed to call this once, you should
CHECK() that.

+  taskqueue_factory = factory;
+}
+
+TaskQueueImplFactory* TaskQueueImplFactory::Get() {
+  if (taskqueue_factory)

[kwiberg-webrtc, 2017/08/21 09:21:55]

Don't read this variable without taking the lock.

+    return taskqueue_factory;
+#if defined(WEBRTC_LINUX)
+  Set(new TaskQueueLibEventFactory());
+#endif
+  return taskqueue_factory;
+}
+
+}  // namespace rtc