Make delegated permissions use mojo generated -permissions.

third_party/WebKit/Source/core/html/HTMLIFrameElementPermissions.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSDstyle license that can be
 // found in the LICENSE file.
 
 #include "core/html/HTMLIFrameElementPermissions.h"
 
 #include "core/html/HTMLIFrameElement.h"
+#include "public/platform/modules/permissions/permission.mojom-blink.h"

[raymes, 2017/02/08 23:07:48]

nit: This is in the header so it's not needed here

[riju_, 2017/02/09 07:53:44]

Done.

 #include "wtf/HashMap.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 namespace {
 
 struct SupportedPermission {
   const char* name;
-  WebPermissionType type;
+  mojom::blink::PermissionName type;
 };
 
 const SupportedPermission kSupportedPermissions[] = {
-    {"geolocation", WebPermissionTypeGeolocation},
-    {"notifications", WebPermissionTypeNotifications},
-    {"midi", WebPermissionTypeMidiSysEx},
+    {"geolocation", mojom::blink::PermissionName::GEOLOCATION},
+    {"notifications", mojom::blink::PermissionName::NOTIFICATIONS},
+    {"midi", mojom::blink::PermissionName::MIDI},
 };
 
 // Returns true if the name is valid and the type is stored in |result|.
-bool getPermissionType(const AtomicString& name, WebPermissionType* result) {
+bool getPermissionType(const AtomicString& name,
+                       mojom::blink::PermissionName* result) {
   for (const SupportedPermission& permission : kSupportedPermissions) {
     if (name == permission.name) {
       if (result)
         *result = permission.type;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace
 
 HTMLIFrameElementPermissions::HTMLIFrameElementPermissions(
     HTMLIFrameElement* element)
     : DOMTokenList(this), m_element(element) {}
 
 HTMLIFrameElementPermissions::~HTMLIFrameElementPermissions() {}
 
 DEFINE_TRACE(HTMLIFrameElementPermissions) {
   visitor->trace(m_element);
   DOMTokenList::trace(visitor);
   DOMTokenListObserver::trace(visitor);
 }
 
-Vector<WebPermissionType>
+Vector<mojom::blink::PermissionName>
 HTMLIFrameElementPermissions::parseDelegatedPermissions(
     String& invalidTokensErrorMessage) const {
-  Vector<WebPermissionType> permissions;
+  Vector<blink::mojom::blink::PermissionName> permissions;
   unsigned numTokenErrors = 0;
   StringBuilder tokenErrors;
   const SpaceSplitString& tokens = this->tokens();
 
   for (size_t i = 0; i < tokens.size(); ++i) {
-    WebPermissionType type;
+    blink::mojom::blink::PermissionName type;
     if (getPermissionType(tokens[i], &type)) {
       permissions.push_back(type);
     } else {
       if (numTokenErrors)
         tokenErrors.append(", '");
       else
         tokenErrors.append('\'');
       tokenErrors.append(tokens[i]);
       tokenErrors.append('\'');
       ++numTokenErrors;
     }
   }
 
   if (numTokenErrors) {
     if (numTokenErrors > 1)
       tokenErrors.append(" are invalid permissions flags.");
     else
       tokenErrors.append(" is an invalid permissions flag.");
     invalidTokensErrorMessage = tokenErrors.toString();
   }
 
   return permissions;
 }
 
 bool HTMLIFrameElementPermissions::validateTokenValue(
     const AtomicString& tokenValue,
     ExceptionState&) const {
-  WebPermissionType unused;
+  mojom::blink::PermissionName unused;
   return getPermissionType(tokenValue, &unused);
 }
 
 void HTMLIFrameElementPermissions::valueWasSet() {
   if (m_element)
     m_element->permissionsValueWasSet();
 }
 
 }  // namespace blink