Remove MOJO_DISALLOW_COPY_AND_ASSIGN and MOJO_ALLOW_UNUSED_LOCAL.

mojo/public/cpp/utility/tests/mutex_unittest.cc

 // Copyright 2014 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 "mojo/public/cpp/utility/mutex.h"
 
 #include <stddef.h>
 #include <stdlib.h>  // For |rand()|.
 #include <time.h>  // For |nanosleep()| (defined by POSIX).
 
 #include <vector>
 
+#include "base/compiler_specific.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/cpp/utility/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 TEST(MutexTest, TrivialSingleThreaded) {
   Mutex mutex;
 
@@ skipping 62 matching lines @@
   }
 
  private:
   static void SleepALittle() {
     static const long kNanosPerMilli = 1000000;
     struct timespec req = {
       0,  // Seconds.
       (rand() % 10) * kNanosPerMilli // Nanoseconds.
     };
     int rv = nanosleep(&req, nullptr);
-    MOJO_ALLOW_UNUSED_LOCAL(rv);
+    ALLOW_UNUSED_LOCAL(rv);
     assert(rv == 0);
   }
 
   const size_t times_to_lock_;
   const Type type_;
   const bool should_sleep_;
   Mutex* const mutex_;
   int* const shared_value_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(Fiddler);
+  DISALLOW_COPY_AND_ASSIGN(Fiddler);
 };
 
 class FiddlerThread : public Thread {
  public:
   // Takes ownership of |fiddler|.
   FiddlerThread(Fiddler* fiddler)
       : fiddler_(fiddler) {
   }
 
   ~FiddlerThread() override { delete fiddler_; }
 
   void Run() override { fiddler_->Fiddle(); }
 
  private:
   Fiddler* const fiddler_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(FiddlerThread);
+  DISALLOW_COPY_AND_ASSIGN(FiddlerThread);
 };
 
 // This does a stress test (that also checks exclusion).
 TEST(MutexTest, ThreadedStress) {
   static const size_t kNumThreads = 20;
   static const int kTimesToLockEach = 20;
   assert(kNumThreads % 4 == 0);
 
   Mutex mutex;
   int shared_value = 0;
@@ skipping 40 matching lines @@
     if (try_lock_succeeded_)
       mutex_->Unlock();
   }
 
   bool try_lock_succeeded() const { return try_lock_succeeded_; }
 
  private:
   Mutex* const mutex_;
   bool try_lock_succeeded_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(TryThread);
+  DISALLOW_COPY_AND_ASSIGN(TryThread);
 };
 
 TEST(MutexTest, TryLock) {
   Mutex mutex;
 
   // |TryLock()| should succeed -- we don't have the lock.
   {
     TryThread thread(&mutex);
     thread.Start();
     thread.Join();
@@ skipping 57 matching lines @@
   // Destroy lock with lock held.
   EXPECT_DEATH_IF_SUPPORTED({
     Mutex mutex;
     mutex.Lock();
   }, "");
 }
 #endif  // !defined(NDEBUG)
 
 }  // namespace
 }  // namespace mojo