Update from https://crrev.com/320343

base/threading/thread_collision_warner_unittest.cc

 // 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.
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_collision_warner.h"
@@ skipping 128 matching lines @@
     }
 
    private:
     DFAKE_MUTEX(push_pop_);
 
     DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
   };
 
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    explicit QueueUser(NonThreadSafeQueue& queue)
-        : queue_(queue) {}
+    explicit QueueUser(NonThreadSafeQueue* queue) : queue_(queue) {}
 
     void Run() override {
-      queue_.push(0);
-      queue_.pop();
+      queue_->push(0);
+      queue_->pop();
     }
 
    private:
-    NonThreadSafeQueue& queue_;
+    NonThreadSafeQueue* queue_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
-  QueueUser queue_user_a(queue);
-  QueueUser queue_user_b(queue);
+  QueueUser queue_user_a(&queue);
+  QueueUser queue_user_b(&queue);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
 
   thread_a.Start();
   thread_b.Start();
 
   thread_a.Join();
   thread_b.Join();
 
@@ skipping 20 matching lines @@
     }
 
    private:
     DFAKE_MUTEX(push_pop_);
 
     DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
   };
 
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    explicit QueueUser(NonThreadSafeQueue& queue)
-        : queue_(queue) {}
+    explicit QueueUser(NonThreadSafeQueue* queue) : queue_(queue) {}
 
     void Run() override {
-      queue_.push(0);
-      queue_.pop();
+      queue_->push(0);
+      queue_->pop();
     }
 
    private:
-    NonThreadSafeQueue& queue_;
+    NonThreadSafeQueue* queue_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
-  QueueUser queue_user_a(queue);
-  QueueUser queue_user_b(queue);
+  QueueUser queue_user_a(&queue);
+  QueueUser queue_user_b(&queue);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
 
   thread_a.Start();
   thread_b.Start();
 
   thread_a.Join();
   thread_b.Join();
 
@@ skipping 22 matching lines @@
    private:
     DFAKE_MUTEX(push_pop_);
 
     DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
   };
 
   // This time the QueueUser class protects the non thread safe queue with
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
-        : queue_(queue),
-          lock_(lock) {}
+    QueueUser(NonThreadSafeQueue* queue, base::Lock* lock)
+        : queue_(queue), lock_(lock) {}
 
     void Run() override {
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.push(0);
+        base::AutoLock auto_lock(*lock_);
+        queue_->push(0);
       }
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.pop();
+        base::AutoLock auto_lock(*lock_);
+        queue_->pop();
       }
     }
    private:
-    NonThreadSafeQueue& queue_;
-    base::Lock& lock_;
+    NonThreadSafeQueue* queue_;
+    base::Lock* lock_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
   base::Lock lock;
 
-  QueueUser queue_user_a(queue, lock);
-  QueueUser queue_user_b(queue, lock);
+  QueueUser queue_user_a(&queue, &lock);
+  QueueUser queue_user_b(&queue, &lock);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
 
   thread_a.Start();
   thread_b.Start();
 
   thread_a.Join();
   thread_b.Join();
 
@@ skipping 27 matching lines @@
    private:
     DFAKE_MUTEX(push_pop_);
 
     DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
   };
 
   // This time the QueueUser class protects the non thread safe queue with
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
-        : queue_(queue),
-          lock_(lock) {}
+    QueueUser(NonThreadSafeQueue* queue, base::Lock* lock)
+        : queue_(queue), lock_(lock) {}
 
     void Run() override {
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.push(0);
+        base::AutoLock auto_lock(*lock_);
+        queue_->push(0);
       }
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.bar();
+        base::AutoLock auto_lock(*lock_);
+        queue_->bar();
       }
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.pop();
+        base::AutoLock auto_lock(*lock_);
+        queue_->pop();
       }
     }
    private:
-    NonThreadSafeQueue& queue_;
-    base::Lock& lock_;
+    NonThreadSafeQueue* queue_;
+    base::Lock* lock_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
   base::Lock lock;
 
-  QueueUser queue_user_a(queue, lock);
-  QueueUser queue_user_b(queue, lock);
+  QueueUser queue_user_a(&queue, &lock);
+  QueueUser queue_user_b(&queue, &lock);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
 
   thread_a.Start();
   thread_b.Start();
 
   thread_a.Join();
   thread_b.Join();
 
   EXPECT_FALSE(local_reporter->fail_state());
 }