Change mojo enums to be scoped enums in the generated C++ bindings.

components/mus/public/cpp/tests/window_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 "components/mus/public/cpp/window.h"
 
 #include <limits.h>
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 498 matching lines @@
     // Move w11 to front.
     // Resulting order: w12, w13, w11
     w11.MoveToFront();
     EXPECT_EQ(&w12, w1.children().front());
     EXPECT_EQ(&w11, w1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&w11, changes[0].window);
     EXPECT_EQ(&w13, changes[0].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_ABOVE, changes[0].direction);
+    EXPECT_EQ(mojom::OrderDirection::ABOVE, changes[0].direction);
 
     EXPECT_EQ(&w11, changes[1].window);
     EXPECT_EQ(&w13, changes[1].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_ABOVE, changes[1].direction);
+    EXPECT_EQ(mojom::OrderDirection::ABOVE, changes[1].direction);
   }
 
   {
     OrderChangeObserver observer(&w11);
 
     // Move w11 to back.
     // Resulting order: w11, w12, w13
     w11.MoveToBack();
     EXPECT_EQ(&w11, w1.children().front());
     EXPECT_EQ(&w13, w1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&w11, changes[0].window);
     EXPECT_EQ(&w12, changes[0].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_BELOW, changes[0].direction);
+    EXPECT_EQ(mojom::OrderDirection::BELOW, changes[0].direction);
 
     EXPECT_EQ(&w11, changes[1].window);
     EXPECT_EQ(&w12, changes[1].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_BELOW, changes[1].direction);
+    EXPECT_EQ(mojom::OrderDirection::BELOW, changes[1].direction);
   }
 
   {
     OrderChangeObserver observer(&w11);
 
     // Move w11 above w12.
     // Resulting order: w12. w11, w13
-    w11.Reorder(&w12, mojom::ORDER_DIRECTION_ABOVE);
+    w11.Reorder(&w12, mojom::OrderDirection::ABOVE);
     EXPECT_EQ(&w12, w1.children().front());
     EXPECT_EQ(&w13, w1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&w11, changes[0].window);
     EXPECT_EQ(&w12, changes[0].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_ABOVE, changes[0].direction);
+    EXPECT_EQ(mojom::OrderDirection::ABOVE, changes[0].direction);
 
     EXPECT_EQ(&w11, changes[1].window);
     EXPECT_EQ(&w12, changes[1].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_ABOVE, changes[1].direction);
+    EXPECT_EQ(mojom::OrderDirection::ABOVE, changes[1].direction);
   }
 
   {
     OrderChangeObserver observer(&w11);
 
     // Move w11 below w12.
     // Resulting order: w11, w12, w13
-    w11.Reorder(&w12, mojom::ORDER_DIRECTION_BELOW);
+    w11.Reorder(&w12, mojom::OrderDirection::BELOW);
     EXPECT_EQ(&w11, w1.children().front());
     EXPECT_EQ(&w13, w1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&w11, changes[0].window);
     EXPECT_EQ(&w12, changes[0].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_BELOW, changes[0].direction);
+    EXPECT_EQ(mojom::OrderDirection::BELOW, changes[0].direction);
 
     EXPECT_EQ(&w11, changes[1].window);
     EXPECT_EQ(&w12, changes[1].relative_window);
-    EXPECT_EQ(mojom::ORDER_DIRECTION_BELOW, changes[1].direction);
+    EXPECT_EQ(mojom::OrderDirection::BELOW, changes[1].direction);
   }
 }
 
 namespace {
 
 typedef std::vector<std::string> Changes;
 
 std::string WindowIdToString(Id id) {
   return (id == 0) ? "null"
                    : base::StringPrintf("%d,%d", HiWord(id), LoWord(id));
@@ skipping 384 matching lines @@
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get()));
 
   // This tests that the order in children_ array rather than in
   // transient_children_ array is used when reinserting transient children.
   // If transient_children_ array was used '22' would be following '21'.
   w2->MoveToFront();
   EXPECT_EQ(w22, parent->children().back());
   EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get()));
 
-  w11->Reorder(w2.get(), mojom::ORDER_DIRECTION_ABOVE);
+  w11->Reorder(w2.get(), mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get()));
 
-  w21->Reorder(w1.get(), mojom::ORDER_DIRECTION_ABOVE);
+  w21->Reorder(w1.get(), mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w22, parent->children().back());
   EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get()));
 
-  w21->Reorder(w22, mojom::ORDER_DIRECTION_ABOVE);
+  w21->Reorder(w22, mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w213, parent->children().back());
   EXPECT_EQ("1 11 2 22 21 211 212 213", ChildWindowIDsAsString(parent.get()));
 
-  w11->Reorder(w21, mojom::ORDER_DIRECTION_ABOVE);
+  w11->Reorder(w21, mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 211 212 213 1 11", ChildWindowIDsAsString(parent.get()));
 
-  w213->Reorder(w21, mojom::ORDER_DIRECTION_ABOVE);
+  w213->Reorder(w21, mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 
   // No change when stacking a transient parent above its transient child.
-  w21->Reorder(w211, mojom::ORDER_DIRECTION_ABOVE);
+  w21->Reorder(w211, mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 
   // This tests that the order in children_ array rather than in
   // transient_children_ array is used when reinserting transient children.
   // If transient_children_ array was used '22' would be following '21'.
-  w2->Reorder(w1.get(), mojom::ORDER_DIRECTION_ABOVE);
+  w2->Reorder(w1.get(), mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w212, parent->children().back());
   EXPECT_EQ("1 11 2 22 21 213 211 212", ChildWindowIDsAsString(parent.get()));
 
-  w11->Reorder(w213, mojom::ORDER_DIRECTION_ABOVE);
+  w11->Reorder(w213, mojom::OrderDirection::ABOVE);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 }
 
 // Tests that transient children are stacked as a unit when using order below.
 TEST_F(WindowTest, TransientWindowsGroupBelow) {
   scoped_ptr<TestWindow> parent(CreateTestWindow(0, nullptr));
   scoped_ptr<TestWindow> w1(CreateTestWindow(1, parent.get()));
 
   TestWindow* w11 = CreateTestWindow(11, parent.get());
@@ skipping 25 matching lines @@
   // transient_children_ array is used when reinserting transient children.
   // If transient_children_ array was used '22' would be following '21'.
   w2->MoveToBack();
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get()));
 
   w1->MoveToBack();
   EXPECT_EQ(w22, parent->children().back());
   EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get()));
 
-  w21->Reorder(w1.get(), mojom::ORDER_DIRECTION_BELOW);
+  w21->Reorder(w1.get(), mojom::OrderDirection::BELOW);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get()));
 
-  w11->Reorder(w2.get(), mojom::ORDER_DIRECTION_BELOW);
+  w11->Reorder(w2.get(), mojom::OrderDirection::BELOW);
   EXPECT_EQ(w22, parent->children().back());
   EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get()));
 
-  w22->Reorder(w21, mojom::ORDER_DIRECTION_BELOW);
+  w22->Reorder(w21, mojom::OrderDirection::BELOW);
   EXPECT_EQ(w213, parent->children().back());
   EXPECT_EQ("1 11 2 22 21 211 212 213", ChildWindowIDsAsString(parent.get()));
 
-  w21->Reorder(w11, mojom::ORDER_DIRECTION_BELOW);
+  w21->Reorder(w11, mojom::OrderDirection::BELOW);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 211 212 213 1 11", ChildWindowIDsAsString(parent.get()));
 
-  w213->Reorder(w211, mojom::ORDER_DIRECTION_BELOW);
+  w213->Reorder(w211, mojom::OrderDirection::BELOW);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 
   // No change when stacking a transient parent below its transient child.
-  w21->Reorder(w211, mojom::ORDER_DIRECTION_BELOW);
+  w21->Reorder(w211, mojom::OrderDirection::BELOW);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 
-  w1->Reorder(w2.get(), mojom::ORDER_DIRECTION_BELOW);
+  w1->Reorder(w2.get(), mojom::OrderDirection::BELOW);
   EXPECT_EQ(w212, parent->children().back());
   EXPECT_EQ("1 11 2 22 21 213 211 212", ChildWindowIDsAsString(parent.get()));
 
-  w213->Reorder(w11, mojom::ORDER_DIRECTION_BELOW);
+  w213->Reorder(w11, mojom::OrderDirection::BELOW);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 }
 
 // Tests that windows are restacked properly after a call to
 // AddTransientWindow() or RemoveTransientWindow).
 TEST_F(WindowTest, RestackUponAddOrRemoveTransientWindow) {
   scoped_ptr<TestWindow> parent(CreateTestWindow(0, nullptr));
   scoped_ptr<TestWindow> windows[4];
   for (int i = 0; i < 4; i++)
@@ skipping 20 matching lines @@
   scoped_ptr<TestWindow> window0(CreateTestWindow(1, parent.get()));
   scoped_ptr<TestWindow> window1(CreateTestWindow(2, parent.get()));
 
   TestWindow* window2 = CreateTestWindow(3, parent.get());
 
   window0->AddTransientWindow(window2);
   EXPECT_EQ("1 3 2", ChildWindowIDsAsString(parent.get()));
 }
 
 }  // namespace mus