Remove MOJO_DISALLOW_COPY_AND_ASSIGN and MOJO_ALLOW_UNUSED_LOCAL.

mojo/public/cpp/utility/tests/run_loop_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/run_loop.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 28 matching lines @@
   void OnHandleError(const Handle& handle, MojoResult result) override {
     error_count_++;
     last_error_result_ = result;
   }
 
  private:
   int ready_count_;
   int error_count_;
   MojoResult last_error_result_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(TestRunLoopHandler);
+  DISALLOW_COPY_AND_ASSIGN(TestRunLoopHandler);
 };
 
 class RunLoopTest : public testing::Test {
  public:
   RunLoopTest() {}
 
   void SetUp() override {
     Test::SetUp();
     RunLoop::SetUp();
   }
   void TearDown() override {
     RunLoop::TearDown();
     Test::TearDown();
   }
 
  private:
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RunLoopTest);
+  DISALLOW_COPY_AND_ASSIGN(RunLoopTest);
 };
 
 // Trivial test to verify Run() with no added handles returns.
 TEST_F(RunLoopTest, ExitsWithNoHandles) {
   RunLoop run_loop;
   run_loop.Run();
 }
 
 class RemoveOnReadyRunLoopHandler : public TestRunLoopHandler {
  public:
   RemoveOnReadyRunLoopHandler() : run_loop_(nullptr) {}
   ~RemoveOnReadyRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
 
   // RunLoopHandler:
   void OnHandleReady(const Handle& handle) override {
     run_loop_->RemoveHandler(handle);
     TestRunLoopHandler::OnHandleReady(handle);
   }
 
  private:
   RunLoop* run_loop_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveOnReadyRunLoopHandler);
+  DISALLOW_COPY_AND_ASSIGN(RemoveOnReadyRunLoopHandler);
 };
 
 // Verifies RunLoop quits when no more handles (handle is removed when ready).
 TEST_F(RunLoopTest, HandleReady) {
   RemoveOnReadyRunLoopHandler handler;
   MessagePipe test_pipe;
   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
 
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
@@ skipping 14 matching lines @@
 
   // RunLoopHandler:
   void OnHandleReady(const Handle& handle) override {
     run_loop_->Quit();
     TestRunLoopHandler::OnHandleReady(handle);
   }
 
  private:
   RunLoop* run_loop_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnReadyRunLoopHandler);
+  DISALLOW_COPY_AND_ASSIGN(QuitOnReadyRunLoopHandler);
 };
 
 // Verifies Quit() from OnHandleReady() quits the loop.
 TEST_F(RunLoopTest, QuitFromReady) {
   QuitOnReadyRunLoopHandler handler;
   MessagePipe test_pipe;
   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
 
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
@@ skipping 14 matching lines @@
 
   // RunLoopHandler:
   void OnHandleError(const Handle& handle, MojoResult result) override {
     run_loop_->Quit();
     TestRunLoopHandler::OnHandleError(handle, result);
   }
 
  private:
   RunLoop* run_loop_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnErrorRunLoopHandler);
+  DISALLOW_COPY_AND_ASSIGN(QuitOnErrorRunLoopHandler);
 };
 
 // Verifies Quit() when the deadline is reached works.
 TEST_F(RunLoopTest, QuitWhenDeadlineExpired) {
   QuitOnErrorRunLoopHandler handler;
   MessagePipe test_pipe;
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 32 matching lines @@
   void OnHandleError(const Handle& handle, MojoResult result) override {
     for (size_t i = 0; i < handles_.size(); i++)
       run_loop_->RemoveHandler(handles_[i]);
     TestRunLoopHandler::OnHandleError(handle, result);
   }
 
  private:
   std::vector<Handle> handles_;
   RunLoop* run_loop_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveManyRunLoopHandler);
+  DISALLOW_COPY_AND_ASSIGN(RemoveManyRunLoopHandler);
 };
 
 // Test that handlers are notified of loop destruction.
 TEST_F(RunLoopTest, MultipleHandleDestruction) {
   RemoveManyRunLoopHandler odd_handler;
   TestRunLoopHandler even_handler;
   MessagePipe test_pipe1, test_pipe2, test_pipe3;
   {
     RunLoop run_loop;
     odd_handler.set_run_loop(&run_loop);
@@ skipping 29 matching lines @@
   void OnHandleError(const Handle& handle, MojoResult result) override {
     run_loop_->AddHandler(this, handle,
                           MOJO_HANDLE_SIGNAL_READABLE,
                           MOJO_DEADLINE_INDEFINITE);
     TestRunLoopHandler::OnHandleError(handle, result);
   }
 
  private:
   RunLoop* run_loop_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(AddHandlerOnErrorHandler);
+  DISALLOW_COPY_AND_ASSIGN(AddHandlerOnErrorHandler);
 };
 
 TEST_F(RunLoopTest, AddHandlerOnError) {
   AddHandlerOnErrorHandler handler;
   MessagePipe test_pipe;
   {
     RunLoop run_loop;
     handler.set_run_loop(&run_loop);
     run_loop.AddHandler(&handler,
                         test_pipe.handle0.get(),
@@ skipping 74 matching lines @@
     EXPECT_EQ(read_result, MOJO_RESULT_OK);
     EXPECT_EQ(read_byte, kSignalMagic);
   }
 
  private:
   RunLoop* run_loop_;
   MessagePipe* pipe_;
   size_t depth_;
   bool reached_depth_limit_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(NestingRunLoopHandler);
+  DISALLOW_COPY_AND_ASSIGN(NestingRunLoopHandler);
 };
 
 const size_t NestingRunLoopHandler::kDepthLimit = 10;
 const char NestingRunLoopHandler::kSignalMagic = 'X';
 
 TEST_F(RunLoopTest, NestedRun) {
   NestingRunLoopHandler handler;
   MessagePipe test_pipe;
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
@@ skipping 49 matching lines @@
   run_loop.AddHandler(&handler,
                       test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE,
                       MOJO_DEADLINE_INDEFINITE);
   run_loop.PostDelayedTask(Closure(QuittingTask(&run_loop)), 0);
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace mojo