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

mojo/public/cpp/bindings/tests/binding_unittest.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.
 
 // Note: This file tests both binding.h (mojo::Binding) and strong_binding.h
 // (mojo::StrongBinding).
 
 #include "mojo/public/cpp/bindings/binding.h"
 
 #include <stdint.h>
@@ skipping 70 matching lines @@
   bool encountered_error = false;
   ServiceImpl impl;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler(
       [&encountered_error]() { encountered_error = true; });
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   {
     Binding<sample::Service> binding(&impl, std::move(request));
-    ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+    ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    called_cb);
     loop().RunUntilIdle();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
   }
   // Now that the Binding is out of scope we should detect an error on the other
   // end of the pipe.
   loop().RunUntilIdle();
   EXPECT_TRUE(encountered_error);
 
   // And calls should fail.
   called = false;
-  ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  called_cb);
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 }
 
 // Tests that the binding's connection error handler gets called when the other
 // end is closed.
 TEST_F(BindingTest, ConnectionError) {
   bool called = false;
   {
@@ skipping 57 matching lines @@
 }
 
 // Tests that explicitly calling Unbind followed by rebinding works.
 TEST_F(BindingTest, Unbind) {
   ServiceImpl impl;
   sample::ServicePtr ptr;
   Binding<sample::Service> binding(&impl, GetProxy(&ptr));
 
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
-  ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  called_cb);
   loop().RunUntilIdle();
   EXPECT_TRUE(called);
 
   called = false;
   auto request = binding.Unbind();
   EXPECT_FALSE(binding.is_bound());
   // All calls should fail when not bound...
-  ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  called_cb);
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 
   called = false;
   binding.Bind(std::move(request));
   EXPECT_TRUE(binding.is_bound());
   // ...and should succeed again when the rebound.
-  ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  called_cb);
   loop().RunUntilIdle();
   EXPECT_TRUE(called);
 }
 
 class IntegerAccessorImpl : public sample::IntegerAccessor {
  public:
   IntegerAccessorImpl() {}
   ~IntegerAccessorImpl() override {}
 
  private:
   // sample::IntegerAccessor implementation.
   void GetInteger(const GetIntegerCallback& callback) override {
-    callback.Run(1, sample::ENUM_VALUE);
+    callback.Run(1, sample::Enum::VALUE);
   }
   void SetInteger(int64_t data, sample::Enum type) override {}
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(IntegerAccessorImpl);
 };
 
 TEST_F(BindingTest, SetInterfacePtrVersion) {
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
   Binding<sample::IntegerAccessor> binding(&impl, &ptr);
   EXPECT_EQ(3u, ptr.version());
 }
 
 TEST_F(BindingTest, PauseResume) {
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
   binding.PauseIncomingMethodCallProcessing();
-  ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  called_cb);
   EXPECT_FALSE(called);
   loop().RunUntilIdle();
   // Frobinate() should not be called as the binding is paused.
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger processing.
   binding.ResumeIncomingMethodCallProcessing();
   loop().RunUntilIdle();
   EXPECT_TRUE(called);
@@ skipping 31 matching lines @@
   bool was_deleted = false;
   ServiceImpl impl(&was_deleted);
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler(
       [&encountered_error]() { encountered_error = true; });
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   {
     StrongBinding<sample::Service> binding(&impl, std::move(request));
-    ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+    ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    called_cb);
     loop().RunUntilIdle();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
   }
   // Now that the StrongBinding is out of scope we should detect an error on the
   // other end of the pipe.
   loop().RunUntilIdle();
   EXPECT_TRUE(encountered_error);
   // But destroying the StrongBinding doesn't destroy the object.
@@ skipping 60 matching lines @@
   was_deleted = false;  // It shouldn't be double-deleted!
   loop().RunUntilIdle();
   EXPECT_TRUE(ptr_error_handler_called);
   EXPECT_FALSE(was_deleted);
 
   EXPECT_FALSE(binding_error_handler_called);
 }
 
 }  // namespace
 }  // mojo