Rename Blink constants generated from IDL files.

third_party/WebKit/Source/core/fileapi/FileError.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 37 matching lines @@
 const char quotaExceededErrorMessage[] = "The operation failed because it would cause the application to exceed its storage quota.";
 const char securityErrorMessage[] = "It was determined that certain files are unsafe for access within a Web application, or that too many calls are being made on file resources.";
 const char syntaxErrorMessage[] = "An invalid or unsupported argument was given, like an invalid line ending specifier.";
 const char typeMismatchErrorMessage[] = "The path supplied exists, but was not an entry of requested type.";
 
 namespace {
 
 ExceptionCode errorCodeToExceptionCode(ErrorCode code)
 {
     switch (code) {
-    case OK:
+    case kOK:
         return 0;
-    case NOT_FOUND_ERR:
+    case kNotFoundErr:
         return NotFoundError;
-    case SECURITY_ERR:
+    case kSecurityErr:
         return SecurityError;
-    case ABORT_ERR:
+    case kAbortErr:
         return AbortError;
-    case NOT_READABLE_ERR:
+    case kNotReadableErr:
         return NotReadableError;
-    case ENCODING_ERR:
+    case kEncodingErr:
         return EncodingError;
-    case NO_MODIFICATION_ALLOWED_ERR:
+    case kNoModificationAllowedErr:
         return NoModificationAllowedError;
-    case INVALID_STATE_ERR:
+    case kInvalidStateErr:
         return InvalidStateError;
-    case SYNTAX_ERR:
+    case kSyntaxErr:
         return SyntaxError;
-    case INVALID_MODIFICATION_ERR:
+    case kInvalidModificationErr:
         return InvalidModificationError;
-    case QUOTA_EXCEEDED_ERR:
+    case kQuotaExceededErr:
         return QuotaExceededError;
-    case TYPE_MISMATCH_ERR:
+    case kTypeMismatchErr:
         return TypeMismatchError;
-    case PATH_EXISTS_ERR:
+    case kPathExistsErr:
         return PathExistsError;
     default:
         ASSERT_NOT_REACHED();
         return code;
     }
 }
 
 const char* errorCodeToMessage(ErrorCode code)
 {
     // Note that some of these do not set message. If message is 0 then the default message is used.
     switch (code) {
-    case OK:
+    case kOK:
         return 0;
-    case SECURITY_ERR:
+    case kSecurityErr:
         return securityErrorMessage;
-    case NOT_FOUND_ERR:
+    case kNotFoundErr:
         return notFoundErrorMessage;
-    case ABORT_ERR:
+    case kAbortErr:
         return abortErrorMessage;
-    case NOT_READABLE_ERR:
+    case kNotReadableErr:
         return notReadableErrorMessage;
-    case ENCODING_ERR:
+    case kEncodingErr:
         return encodingErrorMessage;
-    case NO_MODIFICATION_ALLOWED_ERR:
+    case kNoModificationAllowedErr:
         return noModificationAllowedErrorMessage;
-    case INVALID_STATE_ERR:
+    case kInvalidStateErr:
         return invalidStateErrorMessage;
-    case SYNTAX_ERR:
+    case kSyntaxErr:
         return syntaxErrorMessage;
-    case INVALID_MODIFICATION_ERR:
+    case kInvalidModificationErr:
         return 0;
-    case QUOTA_EXCEEDED_ERR:
+    case kQuotaExceededErr:
         return quotaExceededErrorMessage;
-    case TYPE_MISMATCH_ERR:
+    case kTypeMismatchErr:
         return 0;
-    case PATH_EXISTS_ERR:
+    case kPathExistsErr:
         return pathExistsErrorMessage;
     default:
         ASSERT_NOT_REACHED();
         return 0;
     }
 }
 
 } // namespace
 
 void throwDOMException(ExceptionState& exceptionState, ErrorCode code)
 {
-    if (code == OK)
+    if (code == kOK)
         return;
 
     // SecurityError is special-cased, as we want to route those exceptions through ExceptionState::throwSecurityError.
-    if (code == SECURITY_ERR) {
+    if (code == kSecurityErr) {
         exceptionState.throwSecurityError(securityErrorMessage);
         return;
     }
 
     exceptionState.throwDOMException(errorCodeToExceptionCode(code), errorCodeToMessage(code));
 }
 
 DOMException* createDOMException(ErrorCode code)
 {
-    DCHECK_NE(code, OK);
+    DCHECK_NE(code, kOK);
     return DOMException::create(errorCodeToExceptionCode(code), errorCodeToMessage(code));
 }
 
 } // namespace FileError
 
 } // namespace blink