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

ui/views/mus/platform_window_mus.cc

 // Copyright 2015 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 "ui/views/mus/platform_window_mus.h"
 
 #include "build/build_config.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #include "ui/views/mus/window_manager_connection.h"
 
 namespace views {
 
 namespace {
 static uint32_t accelerated_widget_count = 1;
 
 }  // namespace
 
 PlatformWindowMus::PlatformWindowMus(ui::PlatformWindowDelegate* delegate,
                                      mus::Window* mus_window)
     : delegate_(delegate),
       mus_window_(mus_window),
-      show_state_(mus::mojom::SHOW_STATE_RESTORED),
-      last_cursor_(mus::mojom::CURSOR_NULL),
+      show_state_(mus::mojom::ShowState::RESTORED),
+      last_cursor_(mus::mojom::Cursor::CURSOR_NULL),
       has_capture_(false),
       mus_window_destroyed_(false) {
   DCHECK(delegate_);
   DCHECK(mus_window_);
   mus_window_->AddObserver(this);
   mus_window_->set_input_event_handler(this);
 
   // We need accelerated widget numbers to be different for each
   // window and fit in the smallest sizeof(AcceleratedWidget) uint32_t
   // has this property.
@@ skipping 66 matching lines @@
   // TODO(sky): this is wrong, need real capture api.
   has_capture_ = false;
   NOTIMPLEMENTED();
 }
 
 void PlatformWindowMus::ToggleFullscreen() {
   NOTIMPLEMENTED();
 }
 
 void PlatformWindowMus::Maximize() {
-  SetShowState(mus::mojom::SHOW_STATE_MAXIMIZED);
+  SetShowState(mus::mojom::ShowState::MAXIMIZED);
 }
 
 void PlatformWindowMus::Minimize() {
-  SetShowState(mus::mojom::SHOW_STATE_MINIMIZED);
+  SetShowState(mus::mojom::ShowState::MINIMIZED);
 }
 
 void PlatformWindowMus::Restore() {
-  SetShowState(mus::mojom::SHOW_STATE_RESTORED);
+  SetShowState(mus::mojom::ShowState::RESTORED);
 }
 
 void PlatformWindowMus::SetCursor(ui::PlatformCursor cursor) {
   NOTIMPLEMENTED();
 }
 
 void PlatformWindowMus::MoveCursorTo(const gfx::Point& location) {
   NOTIMPLEMENTED();
 }
 
 void PlatformWindowMus::ConfineCursorToBounds(const gfx::Rect& bounds) {
   NOTIMPLEMENTED();
 }
 
 ui::PlatformImeController* PlatformWindowMus::GetPlatformImeController() {
   return nullptr;
 }
 
 void PlatformWindowMus::SetShowState(mus::mojom::ShowState show_state) {
   mus_window_->SetSharedProperty<int32_t>(
-      mus::mojom::WindowManager::kShowState_Property, show_state);
+      mus::mojom::WindowManager::kShowState_Property,
+      static_cast<int32_t>(show_state));
 }
 
 void PlatformWindowMus::OnWindowDestroyed(mus::Window* window) {
   DCHECK_EQ(mus_window_, window);
   mus_window_destroyed_ = true;
 #ifndef NDEBUG
   weak_factory_.reset(new base::WeakPtrFactory<PlatformWindowMus>(this));
   base::WeakPtr<PlatformWindowMus> weak_ptr = weak_factory_->GetWeakPtr();
 #endif
   delegate_->OnClosed();
@@ skipping 32 matching lines @@
   if (name != mus::mojom::WindowManager::kShowState_Property)
     return;
   mus::mojom::ShowState show_state =
       static_cast<mus::mojom::ShowState>(window->GetSharedProperty<int32_t>(
           mus::mojom::WindowManager::kShowState_Property));
   if (show_state == show_state_)
     return;
   show_state_ = show_state;
   ui::PlatformWindowState state = ui::PLATFORM_WINDOW_STATE_UNKNOWN;
   switch (show_state_) {
-    case mus::mojom::SHOW_STATE_MINIMIZED:
+    case mus::mojom::ShowState::MINIMIZED:
       state = ui::PLATFORM_WINDOW_STATE_MINIMIZED;
       break;
-    case mus::mojom::SHOW_STATE_MAXIMIZED:
+    case mus::mojom::ShowState::MAXIMIZED:
       state = ui::PLATFORM_WINDOW_STATE_MAXIMIZED;
       break;
-    case mus::mojom::SHOW_STATE_RESTORED:
+    case mus::mojom::ShowState::RESTORED:
       state = ui::PLATFORM_WINDOW_STATE_NORMAL;
       break;
-    case mus::mojom::SHOW_STATE_IMMERSIVE:
-    case mus::mojom::SHOW_STATE_PRESENTATION:
+    case mus::mojom::ShowState::IMMERSIVE:
+    case mus::mojom::ShowState::PRESENTATION:
       // This may not be sufficient.
       state = ui::PLATFORM_WINDOW_STATE_FULLSCREEN;
       break;
   }
   delegate_->OnWindowStateChanged(state);
 }
 
 void PlatformWindowMus::OnRequestClose(mus::Window* window) {
   delegate_->OnCloseRequest();
 }
 
 void PlatformWindowMus::OnWindowInputEvent(
     mus::Window* view,
     mus::mojom::EventPtr event,
     scoped_ptr<base::Closure>* ack_callback) {
   // It's possible dispatching the event will spin a nested message loop. Ack
   // the callback now, otherwise we appear unresponsive for the life of the
   // nested message loop.
   (*ack_callback)->Run();
   ack_callback->reset();
   scoped_ptr<ui::Event> ui_event(event.To<scoped_ptr<ui::Event>>());
   delegate_->DispatchEvent(ui_event.get());
 }
 
 }  // namespace views