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

components/mus/ws/window_tree_impl.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/window_tree_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
       is_embed_root_(false),
       window_manager_internal_(nullptr) {
   ServerWindow* window = GetWindow(root_id);
   CHECK(window);
   root_.reset(new WindowId(root_id));
   if (window->GetRoot() == window) {
     access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
     is_embed_root_ = true;
   } else {
     access_policy_.reset(new DefaultAccessPolicy(id_, this));
-    is_embed_root_ =
-        (policy_bitmask & WindowTree::ACCESS_POLICY_EMBED_ROOT) != 0;
+    is_embed_root_ = (policy_bitmask & WindowTree::kAccessPolicyEmbedRoot) != 0;
   }
 }
 
 WindowTreeImpl::~WindowTreeImpl() {
   DestroyWindows();
 }
 
 void WindowTreeImpl::Init(mojom::WindowTreeClient* client,
                           mojom::WindowTreePtr tree) {
   DCHECK(!client_);
   client_ = client;
   std::vector<const ServerWindow*> to_send;
   if (root_.get())
     GetUnknownWindowsFrom(GetWindow(*root_), &to_send);
 
   // TODO(beng): verify that host can actually be nullptr here.
   WindowTreeHostImpl* host = GetHost();
   const ServerWindow* focused_window =
       host ? host->GetFocusedWindow() : nullptr;
   if (focused_window)
     focused_window = access_policy_->GetWindowForFocusChange(focused_window);
   const Id focused_window_transport_id(WindowIdToTransportId(
       focused_window ? focused_window->id() : WindowId()));
 
   client->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
                   focused_window_transport_id,
-                  is_embed_root_ ? WindowTree::ACCESS_POLICY_EMBED_ROOT
-                                 : WindowTree::ACCESS_POLICY_DEFAULT);
+                  is_embed_root_ ? WindowTree::kAccessPolicyEmbedRoot
+                                 : WindowTree::kAccessPolicyDefault);
 }
 
 const ServerWindow* WindowTreeImpl::GetWindow(const WindowId& id) const {
   if (id_ == id.connection_id) {
     WindowMap::const_iterator i = window_map_.find(id.window_id);
     return i == window_map_.end() ? NULL : i->second;
   }
   return connection_manager_->GetWindow(id);
 }
 
@@ skipping 16 matching lines @@
        (is_embed_root_ && IsWindowKnown(connection_root)))) {
     client()->OnEmbeddedAppDisconnected(
         WindowIdToTransportId(*connection->root_));
   }
 }
 
 void WindowTreeImpl::NotifyChangeCompleted(
     uint32_t change_id,
     mojom::WindowManagerErrorCode error_code) {
   client_->OnChangeCompleted(
-      change_id, error_code == mojom::WINDOW_MANAGER_ERROR_CODE_SUCCESS);
+      change_id, error_code == mojom::WindowManagerErrorCode::SUCCESS);
 }
 
 bool WindowTreeImpl::NewWindow(
     const WindowId& window_id,
     const std::map<std::string, std::vector<uint8_t>>& properties) {
   if (window_id.connection_id != id_)
     return false;
   if (window_map_.find(window_id.window_id) != window_map_.end())
     return false;
   window_map_[window_id.window_id] =
@@ skipping 325 matching lines @@
 
   if (!access_policy_->CanReorderWindow(window, relative_window, direction))
     return false;
 
   std::vector<const ServerWindow*> children = window->parent()->GetChildren();
   const size_t child_i =
       std::find(children.begin(), children.end(), window) - children.begin();
   const size_t target_i =
       std::find(children.begin(), children.end(), relative_window) -
       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;
   }
 
   return true;
 }
 
 bool WindowTreeImpl::DeleteWindowImpl(WindowTreeImpl* source,
                                       ServerWindow* window) {
   DCHECK(window);
   DCHECK_EQ(window->id().connection_id, id_);
@@ skipping 495 matching lines @@
   return connection && connection != this;
 }
 
 bool WindowTreeImpl::IsDescendantOfEmbedRoot(const ServerWindow* window) {
   return is_embed_root_ && root_ && GetWindow(*root_)->Contains(window);
 }
 
 }  // namespace ws
 
 }  // namespace mus