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

content/child/background_sync/background_sync_provider.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/child/background_sync/background_sync_provider.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 209 matching lines @@
   delete this;
 }
 
 void BackgroundSyncProvider::RegisterCallback(
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
     BackgroundSyncError error,
     const SyncRegistrationPtr& options) {
   // TODO(iclelland): Determine the correct error message to return in each case
   scoped_ptr<blink::WebSyncRegistration> result;
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE:
+    case BackgroundSyncError::NONE:
       if (!options.is_null())
         result =
             mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
       callbacks->onSuccess(blink::adoptWebPtr(result.release()));
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+    case BackgroundSyncError::NOT_FOUND:
       NOTREACHED();
       break;
-    case BACKGROUND_SYNC_ERROR_STORAGE:
+    case BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+    case BackgroundSyncError::NOT_ALLOWED:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeNoPermission,
                               "Attempted to register a sync event without a "
                               "window or registration tag too long."));
       break;
-    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+    case BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::UnregisterCallback(
     scoped_ptr<blink::WebSyncUnregistrationCallbacks> callbacks,
     BackgroundSyncError error) {
   // TODO(iclelland): Determine the correct error message to return in each case
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE:
+    case BackgroundSyncError::NONE:
       callbacks->onSuccess(true);
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+    case BackgroundSyncError::NOT_FOUND:
       callbacks->onSuccess(false);
       break;
-    case BACKGROUND_SYNC_ERROR_STORAGE:
+    case BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+    case BackgroundSyncError::NOT_ALLOWED:
       // This error should never be returned from
       // BackgroundSyncManager::Unregister
       NOTREACHED();
       break;
-    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+    case BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetRegistrationCallback(
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
     BackgroundSyncError error,
     const SyncRegistrationPtr& options) {
   // TODO(iclelland): Determine the correct error message to return in each case
   scoped_ptr<blink::WebSyncRegistration> result;
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE:
+    case BackgroundSyncError::NONE:
       if (!options.is_null())
         result =
             mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
       callbacks->onSuccess(blink::adoptWebPtr(result.release()));
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+    case BackgroundSyncError::NOT_FOUND:
       callbacks->onSuccess(nullptr);
       break;
-    case BACKGROUND_SYNC_ERROR_STORAGE:
+    case BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+    case BackgroundSyncError::NOT_ALLOWED:
       // This error should never be returned from
       // BackgroundSyncManager::GetRegistration
       NOTREACHED();
       break;
-    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+    case BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetRegistrationsCallback(
     scoped_ptr<blink::WebSyncGetRegistrationsCallbacks> callbacks,
     BackgroundSyncError error,
     const mojo::Array<SyncRegistrationPtr>& registrations) {
   // TODO(iclelland): Determine the correct error message to return in each case
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE: {
+    case BackgroundSyncError::NONE: {
       blink::WebVector<blink::WebSyncRegistration*> results(
           registrations.size());
       for (size_t i = 0; i < registrations.size(); ++i) {
         results[i] = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(
                          registrations[i])
                          .release();
       }
       callbacks->onSuccess(results);
       break;
     }
-    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
-    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+    case BackgroundSyncError::NOT_FOUND:
+    case BackgroundSyncError::NOT_ALLOWED:
       // These errors should never be returned from
       // BackgroundSyncManager::GetRegistrations
       NOTREACHED();
       break;
-    case BACKGROUND_SYNC_ERROR_STORAGE:
+    case BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+    case BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetPermissionStatusCallback(
     scoped_ptr<blink::WebSyncGetPermissionStatusCallbacks> callbacks,
     BackgroundSyncError error,
     PermissionStatus status) {
   // TODO(iclelland): Determine the correct error message to return in each case
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE:
+    case BackgroundSyncError::NONE:
       switch (status) {
-        case PERMISSION_STATUS_GRANTED:
+        case PermissionStatus::GRANTED:
           callbacks->onSuccess(blink::WebSyncPermissionStatusGranted);
           break;
-        case PERMISSION_STATUS_DENIED:
+        case PermissionStatus::DENIED:
           callbacks->onSuccess(blink::WebSyncPermissionStatusDenied);
           break;
-        case PERMISSION_STATUS_ASK:
+        case PermissionStatus::ASK:
           callbacks->onSuccess(blink::WebSyncPermissionStatusPrompt);
           break;
       }
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
-    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+    case BackgroundSyncError::NOT_FOUND:
+    case BackgroundSyncError::NOT_ALLOWED:
       // These errors should never be returned from
       // BackgroundSyncManager::GetPermissionStatus
       NOTREACHED();
       break;
-    case BACKGROUND_SYNC_ERROR_STORAGE:
+    case BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+    case BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::NotifyWhenFinishedCallback(
     scoped_ptr<blink::WebSyncNotifyWhenFinishedCallbacks> callbacks,
     BackgroundSyncError error,
     BackgroundSyncState state) {
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE:
+    case BackgroundSyncError::NONE:
       switch (state) {
-        case BACKGROUND_SYNC_STATE_PENDING:
-        case BACKGROUND_SYNC_STATE_FIRING:
-        case BACKGROUND_SYNC_STATE_REREGISTERED_WHILE_FIRING:
-        case BACKGROUND_SYNC_STATE_UNREGISTERED_WHILE_FIRING:
+        case BackgroundSyncState::PENDING:
+        case BackgroundSyncState::FIRING:
+        case BackgroundSyncState::REREGISTERED_WHILE_FIRING:
+        case BackgroundSyncState::UNREGISTERED_WHILE_FIRING:
           NOTREACHED();
           break;
-        case BACKGROUND_SYNC_STATE_SUCCESS:
+        case BackgroundSyncState::SUCCESS:
           callbacks->onSuccess();
           break;
-        case BACKGROUND_SYNC_STATE_FAILED:
-        case BACKGROUND_SYNC_STATE_UNREGISTERED:
+        case BackgroundSyncState::FAILED:
+        case BackgroundSyncState::UNREGISTERED:
           callbacks->onError(blink::WebSyncError(
               blink::WebSyncError::ErrorTypeAbort,
               "Sync failed, unregistered, or overwritten."));
           break;
       }
       break;
-    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
-    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+    case BackgroundSyncError::NOT_FOUND:
+    case BackgroundSyncError::NOT_ALLOWED:
       NOTREACHED();
       break;
-    case BACKGROUND_SYNC_ERROR_STORAGE:
+    case BackgroundSyncError::STORAGE:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "Background Sync is disabled."));
       break;
-    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+    case BackgroundSyncError::NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 BackgroundSyncServicePtr&
 BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
   if (!background_sync_service_.get()) {
     mojo::InterfaceRequest<BackgroundSyncService> request =
         mojo::GetProxy(&background_sync_service_);
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ConnectToServiceOnMainThread, base::Passed(&request)));
   }
   return background_sync_service_;
 }
 
 }  // namespace content