Update on my last compatibility fix for libevent2.

webrtc/base/task_queue_libevent.cc

 /*
  *  Copyright 2016 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.
  */
 
@@ skipping 23 matching lines @@
   ~TimerEvent() { event_del(&ev); }
   event ev;
   std::unique_ptr<QueuedTask> task;
 };
 
 bool SetNonBlocking(int fd) {
   const int flags = fcntl(fd, F_GETFL);
   RTC_CHECK(flags != -1);
   return (flags & O_NONBLOCK) || fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1;
 }
+
+// TODO(tommi): This is a hack to support two versions of libevent that we're
+// compatible with.  The method we really want to call is event_assign(),
+// since event_set() has been marked as deprecated (and doesn't accept
+// passing event_base__ as a parameter).  However, the version of libevent
+// that we have in Chromium, doesn't have event_assign(), so we need to call
+// event_set() there.
+void EventAssign(struct event* ev,
+                 struct event_base* base,
+                 int fd,
+                 short events,
+                 void (*callback)(int, short, void*),
+                 void* arg) {
+#if defined(_EVENT2_EVENT_H_)
+  RTC_CHECK_EQ(0, event_assign(ev, base, fd, events, callback, arg));
+#else
+  event_set(ev, fd, events, callback, arg);
+  RTC_CHECK_EQ(0, event_base_set(base, ev));
+#endif
+}
 }  // namespace
 
 struct TaskQueue::QueueContext {
   explicit QueueContext(TaskQueue* q) : queue(q), is_active(true) {}
   TaskQueue* queue;
   bool is_active;
   // Holds a list of events pending timers for cleanup when the loop exits.
   std::list<TimerEvent*> pending_timers_;
 };
 
@@ skipping 63 matching lines @@
     : event_base_(event_base_new()),
       wakeup_event_(new event()),
       thread_(&TaskQueue::ThreadMain, this, queue_name) {
   RTC_DCHECK(queue_name);
   int fds[2];
   RTC_CHECK(pipe(fds) == 0);
   SetNonBlocking(fds[0]);
   SetNonBlocking(fds[1]);
   wakeup_pipe_out_ = fds[0];
   wakeup_pipe_in_ = fds[1];
-  // TODO(tommi): This is a hack to support two versions of libevent that we're
-  // compatible with.  The method we really want to call is event_assign(),
-  // since event_set() has been marked as deprecated (and doesn't accept
-  // passing event_base__ as a parameter).  However, the version of libevent
-  // that we have in Chromium, doesn't have event_assign(), so we need to call
-  // event_set() there.
-#if defined(_EVENT2_EVENT_H_)
-  event_assign(wakeup_event_.get(), event_base_, wakeup_pipe_out_,
-               EV_READ | EV_PERSIST, OnWakeup, this);
-#else
-  event_set(wakeup_event_.get(), wakeup_pipe_out_, EV_READ | EV_PERSIST,
-            OnWakeup, this);
-#endif
-  event_base_set(event_base_, wakeup_event_.get());
+  EventAssign(wakeup_event_.get(), event_base_, wakeup_pipe_out_,
+              EV_READ | EV_PERSIST, OnWakeup, this);
   event_add(wakeup_event_.get(), 0);
   thread_.Start();
 }
 
 TaskQueue::~TaskQueue() {
   RTC_DCHECK(!IsCurrent());
   struct timespec ts;
   char message = kQuit;
   while (write(wakeup_pipe_in_, &message, sizeof(message)) != sizeof(message)) {
     // The queue is full, so we have no choice but to wait and retry.
@@ skipping 64 matching lines @@
         return t.get() == task_id;
       });
     }
   }
 }
 
 void TaskQueue::PostDelayedTask(std::unique_ptr<QueuedTask> task,
                                 uint32_t milliseconds) {
   if (IsCurrent()) {
     TimerEvent* timer = new TimerEvent(std::move(task));
-    evtimer_set(&timer->ev, &TaskQueue::RunTimer, timer);
-    event_base_set(event_base_, &timer->ev);
+    EventAssign(&timer->ev, event_base_, -1, 0, &TaskQueue::RunTimer, timer);
     QueueContext* ctx =
         static_cast<QueueContext*>(pthread_getspecific(GetQueuePtrTls()));
     ctx->pending_timers_.push_back(timer);
     timeval tv = {milliseconds / 1000, (milliseconds % 1000) * 1000};
     event_add(&timer->ev, &tv);
   } else {
     PostTask(std::unique_ptr<QueuedTask>(
         new SetTimerTask(std::move(task), milliseconds)));
   }
 }
@@ skipping 83 matching lines @@
   CritScope lock(&pending_lock_);
   pending_replies_.push_back(reply_task);
 }
 
 void TaskQueue::ReplyTaskDone(PostAndReplyTask* reply_task) {
   CritScope lock(&pending_lock_);
   pending_replies_.remove(reply_task);
 }
 
 }  // namespace rtc