Rename Blink constants generated from IDL files.

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

 /*
  * Copyright (C) 2010 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 48 matching lines @@
     , m_client(client)
     , m_urlForReadingIsStream(false)
     , m_isRawDataConverted(false)
     , m_stringResult("")
     , m_finishedLoading(false)
     , m_bytesLoaded(0)
     , m_totalBytes(-1)
     , m_hasRange(false)
     , m_rangeStart(0)
     , m_rangeEnd(0)
-    , m_errorCode(FileError::OK)
+    , m_errorCode(FileError::kOK)
 {
 }
 
 FileReaderLoader::~FileReaderLoader()
 {
     cleanup();
     if (!m_urlForReading.isEmpty()) {
         if (m_urlForReadingIsStream)
             BlobRegistry::unregisterStreamURL(m_urlForReading);
         else
             BlobRegistry::revokePublicBlobURL(m_urlForReading);
     }
 }
 
 void FileReaderLoader::startInternal(ExecutionContext& executionContext, const Stream* stream, PassRefPtr<BlobDataHandle> blobData)
 {
     // The blob is read by routing through the request handling layer given a temporary public url.
     m_urlForReading = BlobURL::createPublicURL(executionContext.getSecurityOrigin());
     if (m_urlForReading.isEmpty()) {
-        failed(FileError::SECURITY_ERR);
+        failed(FileError::kSecurityErr);
         return;
     }
 
     if (blobData) {
         ASSERT(!stream);
         BlobRegistry::registerPublicBlobURL(executionContext.getSecurityOrigin(), m_urlForReading, blobData);
     } else {
         ASSERT(stream);
         BlobRegistry::registerStreamURL(executionContext.getSecurityOrigin(), m_urlForReading, stream->url());
     }
@@ skipping 43 matching lines @@
         m_rangeStart = 0;
         m_rangeEnd = readSize - 1; // End is inclusive so (0,0) is a 1-byte read.
     }
 
     m_urlForReadingIsStream = true;
     startInternal(*executionContext, &stream, nullptr);
 }
 
 void FileReaderLoader::cancel()
 {
-    m_errorCode = FileError::ABORT_ERR;
+    m_errorCode = FileError::kAbortErr;
     cleanup();
 }
 
 void FileReaderLoader::cleanup()
 {
     if (m_loader) {
         m_loader->cancel();
         m_loader = nullptr;
     }
 
@@ skipping 32 matching lines @@
         m_totalBytes = -1;
     }
 
     ASSERT(!m_rawData);
 
     if (m_readType != ReadByClient) {
         // Check that we can cast to unsigned since we have to do
         // so to call ArrayBuffer's create function.
         // FIXME: Support reading more than the current size limit of ArrayBuffer.
         if (initialBufferLength > std::numeric_limits<unsigned>::max()) {
-            failed(FileError::NOT_READABLE_ERR);
+            failed(FileError::kNotReadableErr);
             return;
         }
 
         if (initialBufferLength < 0)
             m_rawData = wrapUnique(new ArrayBufferBuilder());
         else
             m_rawData = wrapUnique(new ArrayBufferBuilder(static_cast<unsigned>(initialBufferLength)));
 
         if (!m_rawData || !m_rawData->isValid()) {
-            failed(FileError::NOT_READABLE_ERR);
+            failed(FileError::kNotReadableErr);
             return;
         }
 
         if (initialBufferLength >= 0) {
             // Total size is known. Set m_rawData to ignore overflowed data.
             m_rawData->setVariableCapacity(false);
         }
     }
 
     if (m_client)
@@ skipping 13 matching lines @@
 
         if (m_client)
             m_client->didReceiveDataForClient(data, dataLength);
         return;
     }
 
     unsigned bytesAppended = m_rawData->append(data, dataLength);
     if (!bytesAppended) {
         m_rawData.reset();
         m_bytesLoaded = 0;
-        failed(FileError::NOT_READABLE_ERR);
+        failed(FileError::kNotReadableErr);
         return;
     }
     m_bytesLoaded += bytesAppended;
     m_isRawDataConverted = false;
 
     if (m_client)
         m_client->didReceiveData();
 }
 
 void FileReaderLoader::didFinishLoading(unsigned long, double)
@@ skipping 13 matching lines @@
     cleanup();
     if (m_client)
         m_client->didFinishLoading();
 }
 
 void FileReaderLoader::didFail(const ResourceError& error)
 {
     if (error.isCancellation())
         return;
     // If we're aborting, do not proceed with normal error handling since it is covered in aborting code.
-    if (m_errorCode == FileError::ABORT_ERR)
+    if (m_errorCode == FileError::kAbortErr)
         return;
 
-    failed(FileError::NOT_READABLE_ERR);
+    failed(FileError::kNotReadableErr);
 }
 
 void FileReaderLoader::failed(FileError::ErrorCode errorCode)
 {
     m_errorCode = errorCode;
     cleanup();
     if (m_client)
         m_client->didFail(m_errorCode);
 }
 
 FileError::ErrorCode FileReaderLoader::httpStatusCodeToErrorCode(int httpStatusCode)
 {
     switch (httpStatusCode) {
     case 403:
-        return FileError::SECURITY_ERR;
+        return FileError::kSecurityErr;
     case 404:
-        return FileError::NOT_FOUND_ERR;
+        return FileError::kNotFoundErr;
     default:
-        return FileError::NOT_READABLE_ERR;
+        return FileError::kNotReadableErr;
     }
 }
 
 DOMArrayBuffer* FileReaderLoader::arrayBufferResult() const
 {
     ASSERT(m_readType == ReadAsArrayBuffer);
 
     // If the loading is not started or an error occurs, return an empty result.
     if (!m_rawData || m_errorCode)
         return nullptr;
@@ skipping 84 matching lines @@
     m_stringResult = builder.toString();
 }
 
 void FileReaderLoader::setEncoding(const String& encoding)
 {
     if (!encoding.isEmpty())
         m_encoding = WTF::TextEncoding(encoding);
 }
 
 } // namespace blink