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

mojo/public/cpp/bindings/tests/interface_ptr_unittest.cc

 // Copyright 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 180 matching lines @@
   IntegerAccessorImpl() : integer_(0) {}
   ~IntegerAccessorImpl() override {}
 
   int64_t integer() const { return integer_; }
 
   void set_closure(const base::Closure& closure) { closure_ = closure; }
 
  private:
   // sample::IntegerAccessor implementation.
   void GetInteger(const GetIntegerCallback& callback) override {
-    callback.Run(integer_, sample::ENUM_VALUE);
+    callback.Run(integer_, sample::Enum::VALUE);
   }
   void SetInteger(int64_t data, sample::Enum type) override {
     integer_ = data;
     if (!closure_.is_null()) {
       closure_.Run();
       closure_.Reset();
     }
   }
 
   int64_t integer_;
@@ skipping 202 matching lines @@
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, ReentrantWaitForIncomingMethodCall) {
   sample::ServicePtr proxy;
   ReentrantServiceImpl impl(GetProxy(&proxy));
 
   base::RunLoop run_loop, run_loop2;
   auto called_cb = [&run_loop](int32_t result) { run_loop.Quit(); };
   auto called_cb2 = [&run_loop2](int32_t result) { run_loop2.Quit(); };
-  proxy->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  proxy->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    called_cb);
-  proxy->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
+  proxy->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    called_cb2);
 
   run_loop.Run();
   run_loop2.Run();
 
   EXPECT_EQ(2, impl.max_call_depth());
 }
 
 TEST_F(InterfacePtrTest, QueryVersion) {
   IntegerAccessorImpl impl;
@@ skipping 18 matching lines @@
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
   Binding<sample::IntegerAccessor> binding(&impl, GetProxy(&ptr));
 
   EXPECT_EQ(0u, ptr.version());
 
   ptr.RequireVersion(1u);
   EXPECT_EQ(1u, ptr.version());
   base::RunLoop run_loop;
   impl.set_closure(run_loop.QuitClosure());
-  ptr->SetInteger(123, sample::ENUM_VALUE);
+  ptr->SetInteger(123, sample::Enum::VALUE);
   run_loop.Run();
   EXPECT_FALSE(ptr.encountered_error());
   EXPECT_EQ(123, impl.integer());
 
   ptr.RequireVersion(3u);
   EXPECT_EQ(3u, ptr.version());
   base::RunLoop run_loop2;
   impl.set_closure(run_loop2.QuitClosure());
-  ptr->SetInteger(456, sample::ENUM_VALUE);
+  ptr->SetInteger(456, sample::Enum::VALUE);
   run_loop2.Run();
   EXPECT_FALSE(ptr.encountered_error());
   EXPECT_EQ(456, impl.integer());
 
   // Require a version that is not supported by the impl side.
   ptr.RequireVersion(4u);
   // This value is set to the input of RequireVersion() synchronously.
   EXPECT_EQ(4u, ptr.version());
   base::RunLoop run_loop3;
   ptr.set_connection_error_handler(run_loop3.QuitClosure());
-  ptr->SetInteger(789, sample::ENUM_VALUE);
+  ptr->SetInteger(789, sample::Enum::VALUE);
   run_loop3.Run();
   EXPECT_TRUE(ptr.encountered_error());
   // The call to SetInteger() after RequireVersion(4u) is ignored.
   EXPECT_EQ(456, impl.integer());
 }
 
 class StrongMathCalculatorImpl : public math::Calculator {
  public:
   StrongMathCalculatorImpl(ScopedMessagePipeHandle handle,
                            bool* error_received,
@@ skipping 214 matching lines @@
   // While B & C have fallen out of scope, the pipes will remain until they are
   // flushed.
   EXPECT_FALSE(a_impl.d_called());
   run_loop.Run();
   EXPECT_TRUE(a_impl.d_called());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo