Rename Blink constants generated from IDL files.

third_party/WebKit/Source/core/fileapi/FileReader.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 180 matching lines @@
 FileReader* FileReader::create(ExecutionContext* context)
 {
     FileReader* fileReader = new FileReader(context);
     fileReader->suspendIfNeeded();
     return fileReader;
 }
 
 FileReader::FileReader(ExecutionContext* context)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
-    , m_state(EMPTY)
+    , m_state(kEmpty)
     , m_loadingState(LoadingStateNone)
     , m_stillFiringEvents(false)
     , m_readType(FileReaderLoader::ReadAsBinaryString)
     , m_lastProgressNotificationTimeMS(0)
 {
 }
 
 FileReader::~FileReader()
 {
     terminate();
@@ skipping 10 matching lines @@
     if (m_loadingState == LoadingStateAborted)
         return;
 
     if (hasPendingActivity())
         ThrottlingController::finishReader(getExecutionContext(), this, ThrottlingController::removeReader(getExecutionContext(), this));
     terminate();
 }
 
 bool FileReader::hasPendingActivity() const
 {
-    return m_state == LOADING || m_stillFiringEvents;
+    return m_state == kLoading || m_stillFiringEvents;
 }
 
 void FileReader::readAsArrayBuffer(Blob* blob, ExceptionState& exceptionState)
 {
     ASSERT(blob);
     DVLOG(1) << "reading as array buffer: " << utf8BlobUUID(blob).data() << " " << utf8FilePath(blob).data();
 
     readInternal(blob, FileReaderLoader::ReadAsArrayBuffer, exceptionState);
 }
 
@@ skipping 22 matching lines @@
 void FileReader::readAsDataURL(Blob* blob, ExceptionState& exceptionState)
 {
     ASSERT(blob);
     DVLOG(1) << "reading as data URL: " << utf8BlobUUID(blob).data() << " " << utf8FilePath(blob).data();
 
     readInternal(blob, FileReaderLoader::ReadAsDataURL, exceptionState);
 }
 
 void FileReader::readInternal(Blob* blob, FileReaderLoader::ReadType type, ExceptionState& exceptionState)
 {
-    // If multiple concurrent read methods are called on the same FileReader, InvalidStateError should be thrown when the state is LOADING.
-    if (m_state == LOADING) {
+    // If multiple concurrent read methods are called on the same FileReader, InvalidStateError should be thrown when the state is kLoading.
+    if (m_state == kLoading) {
         exceptionState.throwDOMException(InvalidStateError, "The object is already busy reading Blobs.");
         return;
     }
 
     if (blob->isClosed()) {
         exceptionState.throwDOMException(InvalidStateError, String(blob->isFile() ? "File" : "Blob") + " has been closed.");
         return;
     }
 
     ExecutionContext* context = getExecutionContext();
     if (!context) {
         exceptionState.throwDOMException(AbortError, "Reading from a detached FileReader is not supported.");
         return;
     }
 
     // A document loader will not load new resources once the Document has detached from its frame.
     if (context->isDocument() && !toDocument(context)->frame()) {
         exceptionState.throwDOMException(AbortError, "Reading from a Document-detached FileReader is not supported.");
         return;
     }
 
     // "Snapshot" the Blob data rather than the Blob itself as ongoing
     // read operations should not be affected if close() is called on
     // the Blob being read.
     m_blobDataHandle = blob->blobDataHandle();
     m_blobType = blob->type();
     m_readType = type;
-    m_state = LOADING;
+    m_state = kLoading;
     m_loadingState = LoadingStatePending;
     m_error = nullptr;
     ASSERT(ThrottlingController::from(context));
     ThrottlingController::pushReader(context, this);
 }
 
 void FileReader::executePendingRead()
 {
     ASSERT(m_loadingState == LoadingStatePending);
     m_loadingState = LoadingStateLoading;
@@ skipping 20 matching lines @@
     }
     m_loadingState = LoadingStateAborted;
 
     // Schedule to have the abort done later since abort() might be called from the event handler and we do not want the resource loading code to be in the stack.
     getExecutionContext()->postTask(
         BLINK_FROM_HERE, createSameThreadTask(&delayedAbort, wrapPersistent(this)));
 }
 
 void FileReader::doAbort()
 {
-    ASSERT(m_state != DONE);
+    DCHECK_NE(kDone, m_state);
     AutoReset<bool> firingEvents(&m_stillFiringEvents, true);
 
     terminate();
 
-    m_error = FileError::createDOMException(FileError::ABORT_ERR);
+    m_error = FileError::createDOMException(FileError::kAbortErr);
 
     // Unregister the reader.
     ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(getExecutionContext(), this);
 
     fireEvent(EventTypeNames::error);
     fireEvent(EventTypeNames::abort);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
     ThrottlingController::finishReader(getExecutionContext(), this, finalStep);
 }
 
 void FileReader::result(StringOrArrayBuffer& resultAttribute) const
 {
     if (!m_loader || m_error)
         return;
 
     if (m_readType == FileReaderLoader::ReadAsArrayBuffer)
         resultAttribute.setArrayBuffer(m_loader->arrayBufferResult());
     else
         resultAttribute.setString(m_loader->stringResult());
 }
 
 void FileReader::terminate()
 {
     if (m_loader) {
         m_loader->cancel();
         m_loader = nullptr;
     }
-    m_state = DONE;
+    m_state = kDone;
     m_loadingState = LoadingStateNone;
 }
 
 void FileReader::didStartLoading()
 {
     AutoReset<bool> firingEvents(&m_stillFiringEvents, true);
     fireEvent(EventTypeNames::loadstart);
 }
 
 void FileReader::didReceiveData()
@@ skipping 22 matching lines @@
     // the stack.
     AutoReset<bool> firingEvents(&m_stillFiringEvents, true);
 
     // It's important that we change m_loadingState before firing any events
     // since any of the events could call abort(), which internally checks
     // if we're still loading (therefore we need abort process) or not.
     m_loadingState = LoadingStateNone;
 
     fireEvent(EventTypeNames::progress);
 
-    ASSERT(m_state != DONE);
-    m_state = DONE;
+    DCHECK_NE(kDone, m_state);
+    m_state = kDone;
 
     // Unregister the reader.
     ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(getExecutionContext(), this);
 
     fireEvent(EventTypeNames::load);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
     ThrottlingController::finishReader(getExecutionContext(), this, finalStep);
 }
 
 void FileReader::didFail(FileError::ErrorCode errorCode)
 {
     if (m_loadingState == LoadingStateAborted)
         return;
 
     AutoReset<bool> firingEvents(&m_stillFiringEvents, true);
 
-    ASSERT(m_loadingState == LoadingStateLoading);
+    DCHECK_EQ(LoadingStateLoading, m_loadingState);
     m_loadingState = LoadingStateNone;
 
-    ASSERT(m_state != DONE);
-    m_state = DONE;
+    DCHECK_NE(kDone, m_state);
+    m_state = kDone;
 
     m_error = FileError::createDOMException(static_cast<FileError::ErrorCode>(errorCode));
 
     // Unregister the reader.
     ThrottlingController::FinishReaderType finalStep = ThrottlingController::removeReader(getExecutionContext(), this);
 
     fireEvent(EventTypeNames::error);
     fireEvent(EventTypeNames::loadend);
 
     // All possible events have fired and we're done, no more pending activity.
@@ skipping 15 matching lines @@
 }
 
 DEFINE_TRACE(FileReader)
 {
     visitor->trace(m_error);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink