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

content/browser/background_sync/background_sync_service_impl.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 "content/browser/background_sync/background_sync_service_impl.h"
 
 #include <utility>
 
 #include "background_sync_registration_handle.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 36 matching lines @@
 }
 
 }  // namespace
 
 #define COMPILE_ASSERT_MATCHING_ENUM(mojo_name, manager_name) \
   static_assert(static_cast<int>(content::mojo_name) ==       \
                     static_cast<int>(content::manager_name),  \
                 "mojo and manager enums must match")
 
 // TODO(iclelland): Move these tests somewhere else
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_ERROR_NONE,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncError::NONE,
                              BACKGROUND_SYNC_STATUS_OK);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_ERROR_STORAGE,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncError::STORAGE,
                              BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_ERROR_NOT_FOUND,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncError::NOT_FOUND,
                              BACKGROUND_SYNC_STATUS_NOT_FOUND);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncError::NO_SERVICE_WORKER,
                              BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_ERROR_NOT_ALLOWED,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncError::NOT_ALLOWED,
                              BACKGROUND_SYNC_STATUS_NOT_ALLOWED);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_ERROR_MAX,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncError::MAX,
                              BACKGROUND_SYNC_STATUS_NOT_ALLOWED);
 
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_NETWORK_STATE_ANY,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::ANY,
                              SyncNetworkState::NETWORK_STATE_ANY);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_NETWORK_STATE_AVOID_CELLULAR,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::AVOID_CELLULAR,
                              SyncNetworkState::NETWORK_STATE_AVOID_CELLULAR);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_NETWORK_STATE_ONLINE,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::ONLINE,
                              SyncNetworkState::NETWORK_STATE_ONLINE);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_NETWORK_STATE_MAX,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::MAX,
                              SyncNetworkState::NETWORK_STATE_ONLINE);
 
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_POWER_STATE_AUTO,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPowerState::AUTO,
                              SyncPowerState::POWER_STATE_AUTO);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_POWER_STATE_AVOID_DRAINING,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPowerState::AVOID_DRAINING,
                              SyncPowerState::POWER_STATE_AVOID_DRAINING);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_POWER_STATE_MAX,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPowerState::MAX,
                              SyncPowerState::POWER_STATE_AVOID_DRAINING);
 
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_PERIODICITY_PERIODIC,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPeriodicity::PERIODIC,
                              SyncPeriodicity::SYNC_PERIODIC);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_PERIODICITY_ONE_SHOT,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPeriodicity::ONE_SHOT,
                              SyncPeriodicity::SYNC_ONE_SHOT);
-COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_PERIODICITY_MAX,
+COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPeriodicity::MAX,
                              SyncPeriodicity::SYNC_ONE_SHOT);
 
 BackgroundSyncServiceImpl::~BackgroundSyncServiceImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(background_sync_context_->background_sync_manager());
 }
 
 BackgroundSyncServiceImpl::BackgroundSyncServiceImpl(
     BackgroundSyncContextImpl* background_sync_context,
     mojo::InterfaceRequest<BackgroundSyncService> request)
@@ skipping 33 matching lines @@
 
 void BackgroundSyncServiceImpl::Unregister(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     int64_t sw_registration_id,
     const UnregisterCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BackgroundSyncRegistrationHandle* registration =
       active_handles_.Lookup(handle_id);
   if (!registration) {
-    callback.Run(BACKGROUND_SYNC_ERROR_NOT_ALLOWED);
+    callback.Run(BackgroundSyncError::NOT_ALLOWED);
     return;
   }
 
   registration->Unregister(
       sw_registration_id,
       base::Bind(&BackgroundSyncServiceImpl::OnUnregisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetRegistration(
@@ skipping 27 matching lines @@
 
 void BackgroundSyncServiceImpl::GetPermissionStatus(
     BackgroundSyncPeriodicity periodicity,
     int64_t sw_registration_id,
     const GetPermissionStatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(iclelland): Implement a real policy. This is a stub implementation.
   // OneShot: crbug.com/482091
   // Periodic: crbug.com/482093
-  callback.Run(BACKGROUND_SYNC_ERROR_NONE, PERMISSION_STATUS_GRANTED);
+  callback.Run(BackgroundSyncError::NONE, PermissionStatus::GRANTED);
 }
 
 void BackgroundSyncServiceImpl::DuplicateRegistrationHandle(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     const DuplicateRegistrationHandleCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
 
   scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle =
       background_sync_manager->DuplicateRegistrationHandle(handle_id);
 
   BackgroundSyncRegistrationHandle* handle_ptr = registration_handle.get();
 
   if (!registration_handle) {
-    callback.Run(BACKGROUND_SYNC_ERROR_NOT_FOUND,
+    callback.Run(BackgroundSyncError::NOT_FOUND,
                  SyncRegistrationPtr(content::SyncRegistration::New()));
     return;
   }
 
   active_handles_.AddWithID(registration_handle.release(),
                             handle_ptr->handle_id());
   SyncRegistrationPtr mojoResult = ToMojoRegistration(*handle_ptr);
-  callback.Run(BACKGROUND_SYNC_ERROR_NONE, std::move(mojoResult));
+  callback.Run(BackgroundSyncError::NONE, std::move(mojoResult));
 }
 
 void BackgroundSyncServiceImpl::ReleaseRegistration(
     BackgroundSyncRegistrationHandle::HandleId handle_id) {
   if (!active_handles_.Lookup(handle_id)) {
     // TODO(jkarlin): Abort client.
     LOG(WARNING) << "Client attempted to release non-existing registration";
     return;
   }
 
   active_handles_.Remove(handle_id);
 }
 
 void BackgroundSyncServiceImpl::NotifyWhenFinished(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     const NotifyWhenFinishedCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncRegistrationHandle* registration =
       active_handles_.Lookup(handle_id);
   if (!registration) {
-    callback.Run(BACKGROUND_SYNC_ERROR_NOT_ALLOWED,
-                 BACKGROUND_SYNC_STATE_FAILED);
+    callback.Run(BackgroundSyncError::NOT_ALLOWED, BackgroundSyncState::FAILED);
     return;
   }
 
   registration->NotifyWhenFinished(
       base::Bind(&BackgroundSyncServiceImpl::OnNotifyWhenFinishedResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::OnRegisterResult(
     const RegisterCallback& callback,
@@ skipping 44 matching lines @@
 
 void BackgroundSyncServiceImpl::OnNotifyWhenFinishedResult(
     const NotifyWhenFinishedCallback& callback,
     BackgroundSyncStatus status,
     BackgroundSyncState sync_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<content::BackgroundSyncError>(status), sync_state);
 }
 
 }  // namespace content