Remove MOJO_DISALLOW_COPY_AND_ASSIGN and MOJO_ALLOW_UNUSED_LOCAL.

components/mus/ws/window_manager_client_apptest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 56 matching lines @@
   // Overridden from WindowObserver:
   void OnWindowBoundsChanged(Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override {
     DCHECK_EQ(window, window_);
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
 };
 
 // Wait until the bounds of the supplied window change; returns false on
 // timeout.
 bool WaitForBoundsToChange(Window* window) {
   BoundsChangeObserver observer(window);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 class ClientAreaChangeObserver : public WindowObserver {
  public:
   explicit ClientAreaChangeObserver(Window* window) : window_(window) {
     window_->AddObserver(this);
   }
   ~ClientAreaChangeObserver() override { window_->RemoveObserver(this); }
 
  private:
   // Overridden from WindowObserver:
   void OnWindowClientAreaChanged(
       Window* window,
       const gfx::Insets& old_client_area,
       const std::vector<gfx::Rect>& old_additional_client_areas) override {
     DCHECK_EQ(window, window_);
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(ClientAreaChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(ClientAreaChangeObserver);
 };
 
 // Wait until the bounds of the supplied window change; returns false on
 // timeout.
 bool WaitForClientAreaToChange(Window* window) {
   ClientAreaChangeObserver observer(window);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 // Spins a run loop until the tree beginning at |root| has |tree_size| windows
@@ skipping 19 matching lines @@
     size_t count = 1;
     Window::Children::const_iterator it = window->children().begin();
     for (; it != window->children().end(); ++it)
       count += CountWindows(*it);
     return count;
   }
 
   Window* tree_;
   size_t tree_size_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
+  DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
 };
 
 // Wait until |window| has |tree_size| descendants; returns false on timeout.
 // The count includes |window|. For example, if you want to wait for |window| to
 // have a single child, use a |tree_size| of 2.
 bool WaitForTreeSizeToMatch(Window* window, size_t tree_size) {
   TreeSizeMatchesObserver observer(window, tree_size);
   return observer.IsTreeCorrectSize() ||
          WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 class OrderChangeObserver : public WindowObserver {
  public:
   OrderChangeObserver(Window* window) : window_(window) {
     window_->AddObserver(this);
   }
   ~OrderChangeObserver() override { window_->RemoveObserver(this); }
 
  private:
   // Overridden from WindowObserver:
   void OnWindowReordered(Window* window,
                          Window* relative_window,
                          mojom::OrderDirection direction) override {
     DCHECK_EQ(window, window_);
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 };
 
 // Wait until |window|'s tree size matches |tree_size|; returns false on
 // timeout.
 bool WaitForOrderChange(WindowTreeConnection* connection, Window* window) {
   OrderChangeObserver observer(window);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 // Tracks a window's destruction. Query is_valid() for current state.
@@ skipping 11 matching lines @@
 
  private:
   // Overridden from WindowObserver:
   void OnWindowDestroyed(Window* window) override {
     DCHECK_EQ(window, window_);
     window_ = nullptr;
   }
 
   Window* window_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(WindowTracker);
+  DISALLOW_COPY_AND_ASSIGN(WindowTracker);
 };
 
 }  // namespace
 
 // WindowServer
 // -----------------------------------------------------------------
 
 struct EmbedResult {
   EmbedResult(WindowTreeConnection* connection, ConnectionSpecificId id)
       : connection(connection), connection_id(id) {}
@@ skipping 102 matching lines @@
   void EmbedCallbackImpl(bool result, ConnectionSpecificId connection_id) {
     embed_details_->callback_run = true;
     embed_details_->result = result;
     embed_details_->connection_id = connection_id;
     if (embed_details_->waiting && (!result || embed_details_->connection))
       EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   scoped_ptr<EmbedDetails> embed_details_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(WindowServerTest);
+  DISALLOW_COPY_AND_ASSIGN(WindowServerTest);
 };
 
 TEST_F(WindowServerTest, RootWindow) {
   ASSERT_NE(nullptr, window_manager());
   EXPECT_EQ(1u, window_manager()->GetRoots().size());
 }
 
 TEST_F(WindowServerTest, Embed) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
@@ skipping 191 matching lines @@
 
  private:
   // Overridden from WindowObserver:
   void OnWindowVisibilityChanged(Window* window) override {
     EXPECT_EQ(window, window_);
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(WindowServerTest, Visible) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
   // Embed another app and verify initial state.
@@ skipping 43 matching lines @@
 
  private:
   // Overridden from WindowObserver:
   void OnWindowDrawnChanged(Window* window) override {
     EXPECT_EQ(window, window_);
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(WindowServerTest, Drawn) {
   Window* window1 = window_manager()->NewWindow();
   window1->SetVisible(true);
   GetFirstWMRoot()->AddChild(window1);
 
   // Embed another app and verify initial state.
@@ skipping 50 matching lines @@
     last_lost_focus_ = lost_focus;
     if (quit_on_change_)
       EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   Window* window_;
   Window* last_gained_focus_;
   Window* last_lost_focus_;
   bool quit_on_change_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
 };
 
 class NullFocusChangeObserver : public WindowTreeConnectionObserver {
  public:
   explicit NullFocusChangeObserver(WindowTreeConnection* connection)
       : connection_(connection) {
     connection_->AddObserver(this);
   }
   ~NullFocusChangeObserver() override { connection_->RemoveObserver(this); }
 
  private:
   // Overridden from WindowTreeConnectionObserver.
   void OnWindowTreeFocusChanged(Window* gained_focus,
                                 Window* lost_focus) override {
     if (!gained_focus)
       EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   WindowTreeConnection* connection_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(NullFocusChangeObserver);
+  DISALLOW_COPY_AND_ASSIGN(NullFocusChangeObserver);
 };
 
 bool WaitForWindowToHaveFocus(Window* window) {
   if (window->HasFocus())
     return true;
   FocusChangeObserver observer(window);
   return WindowServerTestBase::DoRunLoopWithTimeout();
 }
 
 bool WaitForNoWindowToHaveFocus(WindowTreeConnection* connection) {
@@ skipping 187 matching lines @@
     window_ = nullptr;
 
     // We should always get OnWindowDestroyed() before OnConnectionLost().
     EXPECT_FALSE(test_->window_tree_connection_destroyed());
   }
 
   WindowServerTestBase* test_;
   Window* window_;
   bool* got_destroy_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(DestroyedChangedObserver);
+  DISALLOW_COPY_AND_ASSIGN(DestroyedChangedObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a WindowServer sends the right notifications.
 TEST_F(WindowServerTest, DeleteWindowServer) {
   Window* window = window_manager()->NewWindow();
   ASSERT_NE(nullptr, window);
   window->SetVisible(true);
   GetFirstWMRoot()->AddChild(window);
@@ skipping 38 matching lines @@
  private:
   // Overridden from WindowObserver:
   void OnTreeChanged(const TreeChangeParams& params) override {
     if (params.target == window_ && !params.new_parent)
       was_removed_ = true;
   }
 
   Window* window_;
   bool was_removed_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(WindowRemovedFromParentObserver);
+  DISALLOW_COPY_AND_ASSIGN(WindowRemovedFromParentObserver);
 };
 
 TEST_F(WindowServerTest, EmbedRemovesChildren) {
   Window* window1 = window_manager()->NewWindow();
   Window* window2 = window_manager()->NewWindow();
   GetFirstWMRoot()->AddChild(window1);
   window1->AddChild(window2);
 
   WindowRemovedFromParentObserver observer(window2);
   window1->Embed(ConnectAndGetWindowServerClient());
@@ skipping 28 matching lines @@
     // We should always get OnWindowDestroyed() before
     // OnWindowManagerDestroyed().
     EXPECT_FALSE(test_->window_tree_connection_destroyed());
 
     EXPECT_TRUE(WindowServerTestBase::QuitRunLoop());
   }
 
   WindowServerTestBase* test_;
   bool* got_destroy_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(DestroyObserver);
+  DISALLOW_COPY_AND_ASSIGN(DestroyObserver);
 };
 
 }  // namespace
 
 // Verifies deleting a Window that is the root of another connection notifies
 // observers in the right order (OnWindowDestroyed() before
 // OnWindowManagerDestroyed()).
 TEST_F(WindowServerTest, WindowServerDestroyedAfterRootObserver) {
   Window* embed_window = window_manager()->NewWindow();
   GetFirstWMRoot()->AddChild(embed_window);
@@ skipping 146 matching lines @@
   ASSERT_TRUE(window_in_wm);
 
   // Change the bounds in the wm, and make sure the child sees it.
   window_in_wm->SetBounds(gfx::Rect(1, 11, 12, 101));
   ASSERT_TRUE(WaitForBoundsToChange(window_in_second_connection));
   EXPECT_EQ(gfx::Rect(1, 11, 12, 101), window_in_second_connection->bounds());
 }
 
 }  // namespace ws
 }  // namespace mus