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

content/browser/permissions/permission_service_impl.cc

 // Copyright 2014 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/permissions/permission_service_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 
 namespace content {
 
 namespace {
 
 PermissionType PermissionNameToPermissionType(PermissionName name) {
   switch(name) {
-    case PERMISSION_NAME_GEOLOCATION:
+    case PermissionName::GEOLOCATION:
       return PermissionType::GEOLOCATION;
-    case PERMISSION_NAME_NOTIFICATIONS:
+    case PermissionName::NOTIFICATIONS:
       return PermissionType::NOTIFICATIONS;
-    case PERMISSION_NAME_PUSH_NOTIFICATIONS:
+    case PermissionName::PUSH_NOTIFICATIONS:
       return PermissionType::PUSH_MESSAGING;
-    case PERMISSION_NAME_MIDI:
+    case PermissionName::MIDI:
       return PermissionType::MIDI;
-    case PERMISSION_NAME_MIDI_SYSEX:
+    case PermissionName::MIDI_SYSEX:
       return PermissionType::MIDI_SYSEX;
-    case PERMISSION_NAME_PROTECTED_MEDIA_IDENTIFIER:
+    case PermissionName::PROTECTED_MEDIA_IDENTIFIER:
       return PermissionType::PROTECTED_MEDIA_IDENTIFIER;
-    case PERMISSION_NAME_DURABLE_STORAGE:
+    case PermissionName::DURABLE_STORAGE:
       return PermissionType::DURABLE_STORAGE;
-    case PERMISSION_NAME_AUDIO_CAPTURE:
+    case PermissionName::AUDIO_CAPTURE:
       return PermissionType::AUDIO_CAPTURE;
-    case PERMISSION_NAME_VIDEO_CAPTURE:
+    case PermissionName::VIDEO_CAPTURE:
       return PermissionType::VIDEO_CAPTURE;
   }
 
   NOTREACHED();
   return PermissionType::NUM;
 }
 
 // This function allows the usage of the the multiple request map
 // with single requests.
 void PermissionRequestResponseCallbackWrapper(
@@ skipping 12 matching lines @@
       request_count(request_count) {
 }
 
 PermissionServiceImpl::PendingRequest::~PendingRequest() {
   if (callback.is_null())
     return;
 
   mojo::Array<PermissionStatus> result =
       mojo::Array<PermissionStatus>::New(request_count);
   for (int i = 0; i < request_count; ++i)
-    result[i] = PERMISSION_STATUS_DENIED;
+    result[i] = PermissionStatus::DENIED;
   callback.Run(std::move(result));
 }
 
 PermissionServiceImpl::PendingSubscription::PendingSubscription(
     PermissionType permission,
     const GURL& origin,
     const PermissionStatusCallback& callback)
     : id(-1),
       permission(permission),
       origin(origin),
       callback(callback) {
 }
 
 PermissionServiceImpl::PendingSubscription::~PendingSubscription() {
   if (!callback.is_null())
-    callback.Run(PERMISSION_STATUS_ASK);
+    callback.Run(PermissionStatus::ASK);
 }
 
 PermissionServiceImpl::PermissionServiceImpl(
     PermissionServiceContext* context,
     mojo::InterfaceRequest<PermissionService> request)
     : context_(context),
       binding_(this, std::move(request)),
       weak_factory_(this) {
   binding_.set_connection_error_handler(
       base::Bind(&PermissionServiceImpl::OnConnectionError,
@@ skipping 157 matching lines @@
     PermissionName permission,
     const mojo::String& origin,
     const PermissionStatusCallback& callback) {
   GURL origin_url(origin);
   PermissionType permission_type = PermissionNameToPermissionType(permission);
   PermissionStatus status = GetPermissionStatusFromType(permission_type,
                                                         origin_url);
 
   // Resetting the permission should only be possible if the permission is
   // already granted.
-  if (status != PERMISSION_STATUS_GRANTED) {
+  if (status != PermissionStatus::GRANTED) {
     callback.Run(status);
     return;
   }
 
   ResetPermissionStatus(permission_type, origin_url);
 
   callback.Run(GetPermissionStatusFromType(permission_type, origin_url));
 }
 
 void PermissionServiceImpl::GetNextPermissionChange(
@@ skipping 41 matching lines @@
     PermissionName permission, const GURL& origin) {
   return GetPermissionStatusFromType(PermissionNameToPermissionType(permission),
                                      origin);
 }
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatusFromType(
     PermissionType type, const GURL& origin) {
   BrowserContext* browser_context = context_->GetBrowserContext();
   DCHECK(browser_context);
   if (!browser_context->GetPermissionManager())
-    return PERMISSION_STATUS_DENIED;
+    return PermissionStatus::DENIED;
 
   // If the embedding_origin is empty we'll use |origin| instead.
   GURL embedding_origin = context_->GetEmbeddingOrigin();
   return browser_context->GetPermissionManager()->GetPermissionStatus(
       type, origin, embedding_origin.is_empty() ? origin : embedding_origin);
 }
 
 void PermissionServiceImpl::ResetPermissionStatus(PermissionType type,
                                                   const GURL& origin) {
   BrowserContext* browser_context = context_->GetBrowserContext();
@@ skipping 22 matching lines @@
 
   PermissionStatusCallback callback = subscription->callback;
 
   subscription->callback.reset();
   pending_subscriptions_.Remove(pending_subscription_id);
 
   callback.Run(status);
 }
 
 }  // namespace content