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

components/mus/public/cpp/lib/window.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 <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 290 matching lines @@
 void Window::Reorder(Window* relative, mojom::OrderDirection direction) {
   if (!LocalReorder(relative, direction))
     return;
   if (connection_)
     tree_client()->Reorder(this, relative->id(), direction);
 }
 
 void Window::MoveToFront() {
   if (!parent_ || parent_->children_.back() == this)
     return;
-  Reorder(parent_->children_.back(), mojom::ORDER_DIRECTION_ABOVE);
+  Reorder(parent_->children_.back(), mojom::OrderDirection::ABOVE);
 }
 
 void Window::MoveToBack() {
   if (!parent_ || parent_->children_.front() == this)
     return;
-  Reorder(parent_->children_.front(), mojom::ORDER_DIRECTION_BELOW);
+  Reorder(parent_->children_.front(), mojom::OrderDirection::BELOW);
 }
 
 bool Window::Contains(Window* child) const {
   if (!child)
     return false;
   if (child == this)
     return true;
   if (connection_)
     CHECK_EQ(child->connection(), connection_);
   for (Window* p = child->parent(); p; p = p->parent()) {
@@ skipping 33 matching lines @@
   return nullptr;
 }
 
 void Window::SetTextInputState(mojo::TextInputStatePtr state) {
   if (connection_)
     tree_client()->SetWindowTextInputState(id_, std::move(state));
 }
 
 void Window::SetImeVisibility(bool visible, mojo::TextInputStatePtr state) {
   // SetImeVisibility() shouldn't be used if the window is not editable.
-  DCHECK(state.is_null() || state->type != mojo::TEXT_INPUT_TYPE_NONE);
+  DCHECK(state.is_null() || state->type != mojo::TextInputType::NONE);
   if (connection_)
     tree_client()->SetImeVisibility(id_, visible, std::move(state));
 }
 
 void Window::SetFocus() {
   if (connection_ && IsDrawn())
     tree_client()->SetFocus(this);
 }
 
 bool Window::HasFocus() const {
   return connection_ && connection_->GetFocusedWindow() == this;
 }
 
 void Window::SetCanFocus(bool can_focus) {
   if (connection_)
     tree_client()->SetCanFocus(id_, can_focus);
 }
 
 void Window::Embed(mus::mojom::WindowTreeClientPtr client) {
-  Embed(std::move(client), mus::mojom::WindowTree::ACCESS_POLICY_DEFAULT,
+  Embed(std::move(client), mus::mojom::WindowTree::kAccessPolicyDefault,
         base::Bind(&EmptyEmbedCallback));
 }
 
 void Window::Embed(mus::mojom::WindowTreeClientPtr client,
                    uint32_t policy_bitmask,
                    const EmbedCallback& callback) {
   if (PrepareForEmbed())
     tree_client()->Embed(id_, std::move(client), policy_bitmask, callback);
   else
     callback.Run(false, 0);
@@ skipping 74 matching lines @@
 
 Window::Window(WindowTreeConnection* connection, Id id)
     : connection_(connection),
       id_(id),
       parent_(nullptr),
       stacking_target_(nullptr),
       transient_parent_(nullptr),
       input_event_handler_(nullptr),
       viewport_metrics_(CreateEmptyViewportMetrics()),
       visible_(false),
-      cursor_id_(mojom::CURSOR_NULL),
+      cursor_id_(mojom::Cursor::CURSOR_NULL),
       drawn_(false) {}
 
 WindowTreeClientImpl* Window::tree_client() {
   return static_cast<WindowTreeClientImpl*>(connection_);
 }
 
 void Window::SetSharedPropertyInternal(const std::string& name,
                                        const std::vector<uint8_t>* value) {
   if (!OwnsWindowOrIsRoot(this))
     return;
@@ skipping 287 matching lines @@
                                          window->stacking_target_))
     return false;
 
   const size_t child_i = std::find(window->parent_->children_.begin(),
                                    window->parent_->children_.end(), window) -
                          window->parent_->children_.begin();
   const size_t target_i =
       std::find(window->parent_->children_.begin(),
                 window->parent_->children_.end(), relative) -
       window->parent_->children_.begin();
-  if ((direction == mojom::ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
-      (direction == mojom::ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
+  if ((direction == mojom::OrderDirection::ABOVE && child_i == target_i + 1) ||
+      (direction == mojom::OrderDirection::BELOW && child_i + 1 == target_i)) {
     return false;
   }
 
   if (notifier)
     notifier->NotifyWindowReordering();
 
-  const size_t dest_i = direction == mojom::ORDER_DIRECTION_ABOVE
+  const size_t dest_i = direction == mojom::OrderDirection::ABOVE
                             ? (child_i < target_i ? target_i : target_i + 1)
                             : (child_i < target_i ? target_i - 1 : target_i);
   window->parent_->children_.erase(window->parent_->children_.begin() +
                                    child_i);
   window->parent_->children_.insert(window->parent_->children_.begin() + dest_i,
                                     window);
 
   window->NotifyWindowStackingChanged();
 
   if (notifier)
     notifier->NotifyWindowReordered();
 
   return true;
 }
 
 // static
 Window** Window::GetStackingTarget(Window* window) {
   return &window->stacking_target_;
 }
 }  // namespace mus