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

components/mus/ws/server_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/ws/server_window.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
@@ skipping 12 matching lines @@
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate,
                            const WindowId& id,
                            const Properties& properties)
     : delegate_(delegate),
       id_(id),
       parent_(nullptr),
       stacking_target_(nullptr),
       transient_parent_(nullptr),
       visible_(false),
-      cursor_id_(mojom::CURSOR_NULL),
+      cursor_id_(mojom::Cursor::CURSOR_NULL),
       opacity_(1),
       can_focus_(true),
       properties_(properties),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as ServerWindowDrawTracker).
       observers_(
           base::ObserverList<ServerWindowObserver>::NOTIFY_EXISTING_ONLY) {
   DCHECK(delegate);  // Must provide a delegate.
 }
@@ skipping 36 matching lines @@
 }
 
 void ServerWindow::Add(ServerWindow* child) {
   // We assume validation checks happened already.
   DCHECK(child);
   DCHECK(child != this);
   DCHECK(!child->Contains(this));
   if (child->parent() == this) {
     if (children_.size() == 1)
       return;  // Already in the right position.
-    child->Reorder(children_.back(), mojom::ORDER_DIRECTION_ABOVE);
+    child->Reorder(children_.back(), mojom::OrderDirection::ABOVE);
     return;
   }
 
   ServerWindow* old_parent = child->parent();
   FOR_EACH_OBSERVER(ServerWindowObserver, child->observers_,
                     OnWillChangeWindowHierarchy(child, this, old_parent));
 
   if (child->parent())
     child->parent()->RemoveImpl(child);
 
@@ skipping 30 matching lines @@
 
 void ServerWindow::Reorder(ServerWindow* relative,
                            mojom::OrderDirection direction) {
   ReorderImpl(this, relative, direction);
 }
 
 void ServerWindow::StackChildAtBottom(ServerWindow* child) {
   // There's nothing to do if the child is already at the bottom.
   if (children_.size() <= 1 || child == children_.front())
     return;
-  child->Reorder(children_.front(), mojom::ORDER_DIRECTION_BELOW);
+  child->Reorder(children_.front(), mojom::OrderDirection::BELOW);
 }
 
 void ServerWindow::StackChildAtTop(ServerWindow* child) {
   // There's nothing to do if the child is already at the top.
   if (children_.size() <= 1 || child == children_.back())
     return;
-  child->Reorder(children_.back(), mojom::ORDER_DIRECTION_ABOVE);
+  child->Reorder(children_.back(), mojom::OrderDirection::ABOVE);
 }
 
 void ServerWindow::SetBounds(const gfx::Rect& bounds) {
   if (bounds_ == bounds)
     return;
 
   // TODO(fsamuel): figure out how will this work with CompositorFrames.
 
   const gfx::Rect old_bounds = bounds_;
   bounds_ = bounds;
@@ skipping 242 matching lines @@
 
   if (!AdjustStackingForTransientWindows(&window, &relative, &direction,
                                          window->stacking_target_))
     return;
 
   window->parent_->children_.erase(std::find(window->parent_->children_.begin(),
                                              window->parent_->children_.end(),
                                              window));
   Windows::iterator i = std::find(window->parent_->children_.begin(),
                                   window->parent_->children_.end(), relative);
-  if (direction == mojom::ORDER_DIRECTION_ABOVE) {
+  if (direction == mojom::OrderDirection::ABOVE) {
     DCHECK(i != window->parent_->children_.end());
     window->parent_->children_.insert(++i, window);
-  } else if (direction == mojom::ORDER_DIRECTION_BELOW) {
+  } else if (direction == mojom::OrderDirection::BELOW) {
     DCHECK(i != window->parent_->children_.end());
     window->parent_->children_.insert(i, window);
   }
   FOR_EACH_OBSERVER(ServerWindowObserver, window->observers_,
                     OnWindowReordered(window, relative, direction));
   window->OnStackingChanged();
 }
 
 // static
 ServerWindow** ServerWindow::GetStackingTarget(ServerWindow* window) {
   return &window->stacking_target_;
 }
 
 }  // namespace ws
 
 }  // namespace mus