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 61 matching lines @@
       event_source_host_(nullptr),
       is_embed_root_(false),
       window_manager_internal_(nullptr) {
   CHECK(root);
   roots_.insert(root);
   if (root->GetRoot() == root) {
     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;
   CHECK_EQ(1u, roots_.size());
   GetUnknownWindowsFrom(*roots_.begin(), &to_send);
 
   WindowTreeHostImpl* host = GetHost(*roots_.begin());
   const ServerWindow* focused_window =
       host ? host->GetFocusedWindow() : nullptr;
   if (focused_window)
     focused_window = access_policy_->GetWindowForFocusChange(focused_window);
   const Id focused_window_transport_id(MapWindowIdToClient(focused_window));
 
   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 24 matching lines @@
 void WindowTreeImpl::OnWillDestroyWindowTreeHost(
     WindowTreeHostImpl* tree_host) {
   if (event_source_host_ == tree_host)
     event_source_host_ = nullptr;
 }
 
 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 (!IsValidIdForNewWindow(window_id))
     return false;
   window_map_[window_id.window_id] =
       connection_manager_->CreateServerWindow(window_id, properties);
   known_windows_.insert(WindowIdToTransportId(window_id));
@@ skipping 405 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 566 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus