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

components/mus/ws/window_tree_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/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/test_change_tracker.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 
 using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::Array;
 using mojo::Callback;
 using mojo::InterfaceRequest;
 using mojo::RectPtr;
 using mojo::String;
-using mus::mojom::ERROR_CODE_NONE;
 using mus::mojom::ErrorCode;
 using mus::mojom::EventPtr;
 using mus::mojom::ViewportMetricsPtr;
 using mus::mojom::WindowDataPtr;
 using mus::mojom::WindowTree;
 using mus::mojom::WindowTreeClient;
 
 namespace mus {
 namespace ws {
 
@@ skipping 28 matching lines @@
 bool EmbedUrl(mojo::ApplicationImpl* app,
               WindowTree* ws,
               const String& url,
               Id root_id) {
   bool result = false;
   base::RunLoop run_loop;
   {
     mojom::WindowTreeClientPtr client;
     app->ConnectToService(url.get(), &client);
     ws->Embed(root_id, std::move(client),
-              mojom::WindowTree::ACCESS_POLICY_DEFAULT,
+              mojom::WindowTree::kAccessPolicyDefault,
               base::Bind(&EmbedCallbackImpl, &run_loop, &result));
   }
   run_loop.Run();
   return result;
 }
 
 bool Embed(WindowTree* ws, Id root_id, mojom::WindowTreeClientPtr client) {
   bool result = false;
   base::RunLoop run_loop;
   {
     ws->Embed(root_id, std::move(client),
-              mojom::WindowTree::ACCESS_POLICY_DEFAULT,
+              mojom::WindowTree::kAccessPolicyDefault,
               base::Bind(&EmbedCallbackImpl, &run_loop, &result));
   }
   run_loop.Run();
   return result;
 }
 
 void GetWindowTree(WindowTree* ws,
                    Id window_id,
                    std::vector<TestWindow>* windows) {
   base::RunLoop run_loop;
@@ skipping 385 matching lines @@
     return client_factory_->WaitForInstance();
   }
 
   // Establishes a new connection by way of Embed() on the specified
   // WindowTree.
   scoped_ptr<TestWindowTreeClientImpl> EstablishConnectionViaEmbed(
       WindowTree* owner,
       Id root_id,
       int* connection_id) {
     return EstablishConnectionViaEmbedWithPolicyBitmask(
-        owner, root_id, mojom::WindowTree::ACCESS_POLICY_DEFAULT,
-        connection_id);
+        owner, root_id, mojom::WindowTree::kAccessPolicyDefault, connection_id);
   }
 
   scoped_ptr<TestWindowTreeClientImpl>
   EstablishConnectionViaEmbedWithPolicyBitmask(WindowTree* owner,
                                                Id root_id,
                                                uint32_t policy_bitmask,
                                                int* connection_id) {
     if (!EmbedUrl(application_impl(), owner, application_impl()->url(),
                   root_id)) {
       ADD_FAILURE() << "Embed() failed";
@@ skipping 426 matching lines @@
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_2));
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_2, window_2_6));
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_3));
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_4));
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_5));
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_2_1));
 
   {
     changes1()->clear();
     ASSERT_TRUE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
-                                            mojom::ORDER_DIRECTION_ABOVE));
+                                            mojom::OrderDirection::ABOVE));
 
     ws_client1_->WaitForChangeCount(1);
     EXPECT_EQ("Reordered window=" + IdToString(window_2_2) + " relative=" +
                   IdToString(window_2_3) + " direction=above",
               SingleChangeToDescription(*changes1()));
   }
 
   {
     changes1()->clear();
     ASSERT_TRUE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
-                                            mojom::ORDER_DIRECTION_BELOW));
+                                            mojom::OrderDirection::BELOW));
 
     ws_client1_->WaitForChangeCount(1);
     EXPECT_EQ("Reordered window=" + IdToString(window_2_2) + " relative=" +
                   IdToString(window_2_3) + " direction=below",
               SingleChangeToDescription(*changes1()));
   }
 
   // view2 is already below view3.
   EXPECT_FALSE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
-                                           mojom::ORDER_DIRECTION_BELOW));
+                                           mojom::OrderDirection::BELOW));
 
   // view4 & 5 are unknown to connection2_.
   EXPECT_FALSE(ws_client2()->ReorderWindow(window_1_4, window_1_5,
-                                           mojom::ORDER_DIRECTION_ABOVE));
+                                           mojom::OrderDirection::ABOVE));
 
   // view6 & view3 have different parents.
   EXPECT_FALSE(ws_client1()->ReorderWindow(window_2_3, window_2_6,
-                                           mojom::ORDER_DIRECTION_ABOVE));
+                                           mojom::OrderDirection::ABOVE));
 
   // Non-existent window-ids
   EXPECT_FALSE(ws_client1()->ReorderWindow(BuildWindowId(connection_id_1(), 27),
                                            BuildWindowId(connection_id_1(), 28),
-                                           mojom::ORDER_DIRECTION_ABOVE));
+                                           mojom::OrderDirection::ABOVE));
 
   // view7 & view8 are un-parented.
   EXPECT_FALSE(ws_client1()->ReorderWindow(window_2_7, window_2_8,
-                                           mojom::ORDER_DIRECTION_ABOVE));
+                                           mojom::OrderDirection::ABOVE));
 }
 
 // Verifies DeleteWindow works.
 TEST_F(WindowTreeAppTest, DeleteWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_2 = ws_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_2);
 
   // Make 2 a child of 1.
@@ skipping 416 matching lines @@
   }
 }
 
 // Test that we hear the cursor change in other connections.
 TEST_F(WindowTreeAppTest, SetCursor) {
   // Get a second connection to listen in.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   changes2()->clear();
 
-  ASSERT_TRUE(ws_client1()->SetPredefinedCursor(window_1_1,
-                                                mojom::Cursor::CURSOR_IBEAM));
+  ASSERT_TRUE(
+      ws_client1()->SetPredefinedCursor(window_1_1, mojom::Cursor::IBEAM));
   ws_client2_->WaitForChangeCount(1u);
 
   EXPECT_EQ("CursorChanged id=" + IdToString(window_1_1) + " cursor_id=4",
             SingleChangeToDescription(*changes2()));
 }
 
 // Assertions for SetWindowVisibility sending notifications.
 TEST_F(WindowTreeAppTest, SetWindowVisibilityNotifications) {
   // Create 1,1 and 1,2. 1,2 is made a child of 1,1 and 1,1 a child of the root.
   Id window_1_1 = ws_client1()->NewWindow(1);
@@ skipping 269 matching lines @@
 
   // Need to wait for a WindowTreeClient for same reason as above.
   WaitForWindowTreeClient();
 
   Id window_1_2 = ws_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(
       ws_client1()->AddWindow(BuildWindowId(connection_id_1(), 1), window_1_2));
   ASSERT_TRUE(ws_client3_.get() == nullptr);
   ws_client3_ = EstablishConnectionViaEmbedWithPolicyBitmask(
-      ws1(), window_1_2, mojom::WindowTree::ACCESS_POLICY_EMBED_ROOT, nullptr);
+      ws1(), window_1_2, mojom::WindowTree::kAccessPolicyEmbedRoot, nullptr);
   ASSERT_TRUE(ws_client3_.get() != nullptr);
   ws_client3_->set_root_window(root_window_id());
 
   // window_1_2 is ws3's root, so even though v3 is an embed root it should not
   // be able to Embed into itself.
   ASSERT_FALSE(EmbedUrl(application_impl(), ws3(), application_impl()->url(),
                         window_1_2));
 }
 
 // Verifies that a transient window tracks its parent's lifetime.
@@ skipping 47 matching lines @@
 // originating connection.
 
 // TODO(sky): make sure coverage of what was
 // WindowManagerTest.SecondEmbedRoot_InitService and
 // WindowManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window
 // manager
 // tests.
 
 }  // namespace ws
 }  // namespace mus