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

components/mus/ws/window_tree_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 <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 18 matching lines @@
 #include "mojo/services/network/public/interfaces/url_loader.mojom.h"
 #include "mojo/shell/public/interfaces/service_provider.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 using mojo::Array;
 using mojo::InterfaceRequest;
 using mojo::String;
-using mus::mojom::ERROR_CODE_NONE;
 using mus::mojom::Event;
 using mus::mojom::EventPtr;
 using mus::mojom::LocationData;
 using mus::mojom::PointerData;
 using mus::mojom::WindowDataPtr;
 
 namespace mus {
 namespace ws {
 namespace {
 
@@ skipping 227 matching lines @@
                                ConnectionManager* manager)
       : WindowTreeHostConnection(std::move(host_impl), manager) {}
   ~TestWindowTreeHostConnection() override {}
 
  private:
   // WindowTreeHostDelegate:
   void OnDisplayInitialized() override {
     connection_manager()->AddHost(this);
     set_window_tree(connection_manager()->EmbedAtWindow(
         window_tree_host()->root_window(),
-        mus::mojom::WindowTree::ACCESS_POLICY_EMBED_ROOT,
+        mus::mojom::WindowTree::kAccessPolicyEmbedRoot,
         mus::mojom::WindowTreeClientPtr()));
   }
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeHostConnection);
 };
 
 // -----------------------------------------------------------------------------
 // Empty implementation of DisplayManager.
 class TestDisplayManager : public DisplayManager {
  public:
   explicit TestDisplayManager(int32_t* cursor_id_storage)
@@ skipping 106 matching lines @@
     return delegate_.last_connection();
   }
 
   ConnectionManager* connection_manager() { return connection_manager_.get(); }
 
   ServerWindow* GetWindowById(const WindowId& id) {
     return connection_manager_->GetWindow(id);
   }
 
   TestWindowTreeClient* wm_client() { return wm_client_; }
-  int32_t cursor_id() { return cursor_id_; }
+  mus::mojom::Cursor cursor_id() {
+    return static_cast<mus::mojom::Cursor>(cursor_id_);
+  }
 
   TestWindowTreeHostConnection* host_connection() { return host_connection_; }
 
   void DispatchEventWithoutAck(const ui::Event& event) {
     host_connection()->window_tree_host()->OnEvent(event);
   }
 
   void set_window_manager_internal(WindowTreeImpl* connection,
                                    mojom::WindowManagerInternal* wm_internal) {
     connection->window_manager_internal_ = wm_internal;
@@ skipping 62 matching lines @@
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRoot(wm_connection())->id(),
                                          embed_window_id));
   host_connection()->window_tree_host()->root_window()->SetBounds(
       gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
   mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
       GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   ConnectionSpecificId connection_id = 0;
   wm_connection()->Embed(embed_window_id, std::move(client),
-                         mojom::WindowTree::ACCESS_POLICY_DEFAULT,
+                         mojom::WindowTree::kAccessPolicyDefault,
                          &connection_id);
   WindowTreeImpl* connection1 = connection_manager()->GetConnectionWithRoot(
       GetWindowById(embed_window_id));
   ASSERT_TRUE(connection1 != nullptr);
   ASSERT_NE(connection1, wm_connection());
 
   connection_manager()
       ->GetWindow(embed_window_id)
       ->SetBounds(gfx::Rect(0, 0, 50, 50));
 
@@ skipping 27 matching lines @@
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRoot(wm_connection())->id(),
                                          embed_window_id));
   host_connection()->window_tree_host()->root_window()->SetBounds(
       gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
   mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
       GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   ConnectionSpecificId connection_id = 0;
   wm_connection()->Embed(embed_window_id, std::move(client),
-                         mojom::WindowTree::ACCESS_POLICY_DEFAULT,
+                         mojom::WindowTree::kAccessPolicyDefault,
                          &connection_id);
   WindowTreeImpl* connection1 = connection_manager()->GetConnectionWithRoot(
       GetWindowById(embed_window_id));
   ASSERT_TRUE(connection1 != nullptr);
   ASSERT_NE(connection1, wm_connection());
 
   connection_manager()
       ->GetWindow(embed_window_id)
       ->SetBounds(gfx::Rect(0, 0, 50, 50));
 
@@ skipping 81 matching lines @@
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
 
   // Like in BasicInputEventTarget, we send a pointer down event to be
   // dispatched. This is only to place the mouse cursor over that window though.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
 
-  window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  window->SetPredefinedCursor(mojom::Cursor::IBEAM);
 
   // Because the cursor is over the window when SetCursor was called, we should
   // have immediately changed the cursor.
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 }
 
 TEST_F(WindowTreeTest, CursorChangesWhenEnteringWindowWithDifferentCursor) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
 
   // Let's create a pointer event outside the window and then move the pointer
   // inside.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  window->SetPredefinedCursor(mojom::Cursor::IBEAM);
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 }
 
 TEST_F(WindowTreeTest, TouchesDontChangeCursor) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
 
   // Let's create a pointer event outside the window and then move the pointer
   // inside.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  window->SetPredefinedCursor(mojom::Cursor::IBEAM);
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 
   // With a touch event, we shouldn't update the cursor.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 }
 
 TEST_F(WindowTreeTest, DragOutsideWindow) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
 
   // Start with the cursor outside the window. Setting the cursor shouldn't
   // change the cursor.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  window->SetPredefinedCursor(mojom::Cursor::IBEAM);
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 
   // Move the pointer to the inside of the window
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 
   // Start the drag.
   DispatchEventAndAckImmediately(CreateMouseDownEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 
   // Move the cursor (mouse is still down) outside the window.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 
   // Release the cursor. We should now adapt the cursor of the window
   // underneath the pointer.
   DispatchEventAndAckImmediately(CreateMouseUpEvent(5, 5));
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 }
 
 TEST_F(WindowTreeTest, ChangingWindowBoundsChangesCursor) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
 
   // Put the cursor just outside the bounds of the window.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(41, 41));
-  window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  window->SetPredefinedCursor(mojom::Cursor::IBEAM);
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 
   // Expand the bounds of the window so they now include where the cursor now
   // is.
   window->SetBounds(gfx::Rect(20, 20, 25, 25));
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 
   // Contract the bounds again.
   window->SetBounds(gfx::Rect(20, 20, 20, 20));
   EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
 }
 
 TEST_F(WindowTreeTest, WindowReorderingChangesCursor) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTreeImpl* window_tree_connection = nullptr;
   ServerWindow* window1 = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(
       &embed_connection, &window_tree_connection, &window1));
 
   // Create a second window right over the first.
   const WindowId embed_window_id(wm_connection()->id(), 1);
   const WindowId child2(window_tree_connection->id(), 2);
   EXPECT_TRUE(
       window_tree_connection->NewWindow(child2, ServerWindow::Properties()));
   EXPECT_TRUE(window_tree_connection->AddWindow(embed_window_id, child2));
   window_tree_connection->GetHost(
                             GetWindowById(WindowId(wm_connection()->id(), 1)))
       ->AddActivationParent(WindowIdToTransportId(embed_window_id));
   ServerWindow* window2 = window_tree_connection->GetWindow(child2);
   window2->SetVisible(true);
   window2->SetBounds(gfx::Rect(20, 20, 20, 20));
   EnableHitTest(window2);
 
   // Give each window a different cursor.
-  window1->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
-  window2->SetPredefinedCursor(mojom::Cursor::CURSOR_HAND);
+  window1->SetPredefinedCursor(mojom::Cursor::IBEAM);
+  window2->SetPredefinedCursor(mojom::Cursor::HAND);
 
   // We expect window2 to be over window1 now.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(22, 22));
-  EXPECT_EQ(mojom::Cursor::CURSOR_HAND, cursor_id());
+  EXPECT_EQ(mojom::Cursor::HAND, cursor_id());
 
   // But when we put window2 at the bottom, we should adapt window1's cursor.
   window2->parent()->StackChildAtBottom(window2);
-  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 }
 
 TEST_F(WindowTreeTest, EventAck) {
   const WindowId embed_window_id(wm_connection()->id(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_connection()));
   EXPECT_TRUE(wm_connection()->AddWindow(FirstRoot(wm_connection())->id(),
                                          embed_window_id));
@@ skipping 75 matching lines @@
             SingleChangeToDescription(*embed_connection->tracker()->changes()));
 
   // Set the visibility from the child using the client assigned id.
   ASSERT_TRUE(window_tree_connection->SetWindowVisibility(
       embed_window_id2_in_child, false));
   EXPECT_FALSE(embed_window->visible());
 }
 
 }  // namespace ws
 }  // namespace mus