Change file_error::ErrorCode to be an enum class.

This patch makes file_error::ErrorCode to be an enum class for better
type safety and improving code health. Using forward declaration in
other header files instead of including |file_error.h|.

Change-Id: I53eae14c2972bb792b474d36e4b8c4bc52c09b0f
Reviewed-on: https://chromium-review.googlesource.com/c/1314083Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Commit-Queue: Zhuoyu Qian <zhuoyu.qian@samsung.com>
Cr-Commit-Position: refs/heads/master@{#606737}

third_party/blink/renderer/core/fileapi/file_error.cc

@@ -74,31 +74,31 @@ namespace {
 
 DOMExceptionCode ErrorCodeToExceptionCode(ErrorCode code) {
   switch (code) {
-    case kOK:
+    case ErrorCode::kOK:
       return DOMExceptionCode::kNoError;
-    case kNotFoundErr:
+    case ErrorCode::kNotFoundErr:
       return DOMExceptionCode::kNotFoundError;
-    case kSecurityErr:
+    case ErrorCode::kSecurityErr:
       return DOMExceptionCode::kSecurityError;
-    case kAbortErr:
+    case ErrorCode::kAbortErr:
       return DOMExceptionCode::kAbortError;
-    case kNotReadableErr:
+    case ErrorCode::kNotReadableErr:
       return DOMExceptionCode::kNotReadableError;
-    case kEncodingErr:
+    case ErrorCode::kEncodingErr:
       return DOMExceptionCode::kEncodingError;
-    case kNoModificationAllowedErr:
+    case ErrorCode::kNoModificationAllowedErr:
       return DOMExceptionCode::kNoModificationAllowedError;
-    case kInvalidStateErr:
+    case ErrorCode::kInvalidStateErr:
       return DOMExceptionCode::kInvalidStateError;
-    case kSyntaxErr:
+    case ErrorCode::kSyntaxErr:
       return DOMExceptionCode::kSyntaxError;
-    case kInvalidModificationErr:
+    case ErrorCode::kInvalidModificationErr:
       return DOMExceptionCode::kInvalidModificationError;
-    case kQuotaExceededErr:
+    case ErrorCode::kQuotaExceededErr:
       return DOMExceptionCode::kQuotaExceededError;
-    case kTypeMismatchErr:
+    case ErrorCode::kTypeMismatchErr:
       return DOMExceptionCode::kTypeMismatchError;
-    case kPathExistsErr:
+    case ErrorCode::kPathExistsErr:
       return DOMExceptionCode::kPathExistsError;
     default:
       NOTREACHED();
@@ -110,31 +110,31 @@ 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 kOK:
+    case ErrorCode::kOK:
       return nullptr;
-    case kSecurityErr:
+    case ErrorCode::kSecurityErr:
       return kSecurityErrorMessage;
-    case kNotFoundErr:
+    case ErrorCode::kNotFoundErr:
       return kNotFoundErrorMessage;
-    case kAbortErr:
+    case ErrorCode::kAbortErr:
       return kAbortErrorMessage;
-    case kNotReadableErr:
+    case ErrorCode::kNotReadableErr:
       return kNotReadableErrorMessage;
-    case kEncodingErr:
+    case ErrorCode::kEncodingErr:
       return kEncodingErrorMessage;
-    case kNoModificationAllowedErr:
+    case ErrorCode::kNoModificationAllowedErr:
       return kNoModificationAllowedErrorMessage;
-    case kInvalidStateErr:
+    case ErrorCode::kInvalidStateErr:
       return kInvalidStateErrorMessage;
-    case kSyntaxErr:
+    case ErrorCode::kSyntaxErr:
       return kSyntaxErrorMessage;
-    case kInvalidModificationErr:
+    case ErrorCode::kInvalidModificationErr:
       return nullptr;
-    case kQuotaExceededErr:
+    case ErrorCode::kQuotaExceededErr:
       return kQuotaExceededErrorMessage;
-    case kTypeMismatchErr:
+    case ErrorCode::kTypeMismatchErr:
       return nullptr;
-    case kPathExistsErr:
+    case ErrorCode::kPathExistsErr:
       return kPathExistsErrorMessage;
     default:
       NOTREACHED();
@@ -231,12 +231,12 @@ const char* FileErrorToMessage(base::File::Error code) {
 void ThrowDOMException(ExceptionState& exception_state,
                        ErrorCode code,
                        String message) {
-  if (code == kOK)
+  if (code == ErrorCode::kOK)
     return;
 
   // SecurityError is special-cased, as we want to route those exceptions
   // through ExceptionState::ThrowSecurityError.
-  if (code == kSecurityErr) {
+  if (code == ErrorCode::kSecurityErr) {
     exception_state.ThrowSecurityError(kSecurityErrorMessage);
     return;
   }
@@ -269,7 +269,7 @@ void ThrowDOMException(ExceptionState& exception_state,
 }
 
 DOMException* CreateDOMException(ErrorCode code) {
-  DCHECK_NE(code, kOK);
+  DCHECK_NE(code, ErrorCode::kOK);
   return DOMException::Create(ErrorCodeToExceptionCode(code),
                               ErrorCodeToMessage(code));
 }

third_party/blink/renderer/core/fileapi/file_error.h

@@ -42,7 +42,7 @@ class ExceptionState;
 
 namespace file_error {
 
-enum ErrorCode {
+enum class ErrorCode {
   kOK = 0,
   kNotFoundErr = 1,
   kSecurityErr = 2,

third_party/blink/renderer/core/fileapi/file_reader.cc

@@ -37,6 +37,7 @@
 #include "third_party/blink/renderer/core/events/progress_event.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/fileapi/file.h"
+#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/core/frame/use_counter.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
 #include "third_party/blink/renderer/core/typed_arrays/dom_array_buffer.h"
@@ -337,7 +338,7 @@ void FileReader::abort() {
   base::AutoReset<bool> firing_events(&still_firing_events_, true);
 
   // Setting error implicitly makes |result| return null.
-  error_ = file_error::CreateDOMException(file_error::kAbortErr);
+  error_ = file_error::CreateDOMException(file_error::ErrorCode::kAbortErr);
 
   // Unregister the reader.
   ThrottlingController::FinishReaderType final_step =

third_party/blink/renderer/core/fileapi/file_reader.h

@@ -36,7 +36,6 @@
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/dom/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/core/dom/events/event_target.h"
-#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/core/fileapi/file_reader_loader.h"
 #include "third_party/blink/renderer/core/fileapi/file_reader_loader_client.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
@@ -44,6 +43,10 @@
 
 namespace blink {
 
+namespace file_error {
+enum class ErrorCode;
+}
+
 class Blob;
 class ExceptionState;
 class ExecutionContext;

third_party/blink/renderer/core/fileapi/file_reader_loader.cc

@@ -100,7 +100,8 @@ void FileReaderLoader::Start(scoped_refptr<BlobDataHandle> blob_data) {
   mojo::ScopedDataPipeProducerHandle producer_handle;
   MojoResult rv = CreateDataPipe(&options, &producer_handle, &consumer_handle_);
   if (rv != MOJO_RESULT_OK) {
-    Failed(file_error::kNotReadableErr, FailureType::kMojoPipeCreation);
+    Failed(file_error::ErrorCode::kNotReadableErr,
+           FailureType::kMojoPipeCreation);
     return;
   }
 
@@ -115,21 +116,22 @@ void FileReaderLoader::Start(scoped_refptr<BlobDataHandle> blob_data) {
     if (received_on_complete_)
       return;
     if (!received_all_data_) {
-      Failed(file_error::kNotReadableErr, FailureType::kSyncDataNotAllLoaded);
+      Failed(file_error::ErrorCode::kNotReadableErr,
+             FailureType::kSyncDataNotAllLoaded);
       return;
     }
 
     // Wait for OnComplete
     binding_.WaitForIncomingMethodCall();
     if (!received_on_complete_) {
-      Failed(file_error::kNotReadableErr,
+      Failed(file_error::ErrorCode::kNotReadableErr,
              FailureType::kSyncOnCompleteNotReceived);
     }
   }
 }
 
 void FileReaderLoader::Cancel() {
-  error_code_ = file_error::kAbortErr;
+  error_code_ = file_error::ErrorCode::kAbortErr;
   Cleanup();
 }
 
@@ -139,7 +141,7 @@ DOMArrayBuffer* FileReaderLoader::ArrayBufferResult() {
     return array_buffer_result_;
 
   // If the loading is not started or an error occurs, return an empty result.
-  if (!raw_data_ || error_code_)
+  if (!raw_data_ || error_code_ != file_error::ErrorCode::kOK)
     return nullptr;
 
   DOMArrayBuffer* result = DOMArrayBuffer::Create(raw_data_->ToArrayBuffer());
@@ -156,8 +158,10 @@ String FileReaderLoader::StringResult() {
   DCHECK_NE(read_type_, kReadAsArrayBuffer);
   DCHECK_NE(read_type_, kReadByClient);
 
-  if (!raw_data_ || error_code_ || is_raw_data_converted_)
+  if (!raw_data_ || (error_code_ != file_error::ErrorCode::kOK) ||
+      is_raw_data_converted_) {
     return string_result_;
+  }
 
   switch (read_type_) {
     case kReadAsArrayBuffer:
@@ -197,7 +201,7 @@ void FileReaderLoader::Cleanup() {
   consumer_handle_.reset();
 
   // If we get any error, we do not need to keep a buffer around.
-  if (error_code_) {
+  if (error_code_ != file_error::ErrorCode::kOK) {
     raw_data_.reset();
     string_result_ = "";
     is_raw_data_converted_ = true;
@@ -213,7 +217,7 @@ void FileReaderLoader::Failed(file_error::ErrorCode error_code,
                                   ("Storage.Blob.FileReaderLoader.FailureType",
                                    static_cast<int>(FailureType::kCount)));
   // If an error was already reported, don't report this error again.
-  if (error_code_ != file_error::kOK)
+  if (error_code_ != file_error::ErrorCode::kOK)
     return;
   error_code_ = error_code;
   failure_histogram.Count(static_cast<int>(type));
@@ -232,13 +236,14 @@ void FileReaderLoader::OnStartLoading(uint64_t total_bytes) {
     // so to call ArrayBuffer's create function.
     // FIXME: Support reading more than the current size limit of ArrayBuffer.
     if (total_bytes > std::numeric_limits<unsigned>::max()) {
-      Failed(file_error::kNotReadableErr, FailureType::kTotalBytesTooLarge);
+      Failed(file_error::ErrorCode::kNotReadableErr,
+             FailureType::kTotalBytesTooLarge);
       return;
     }
 
     raw_data_ = std::make_unique<ArrayBufferBuilder>(total_bytes);
     if (!raw_data_->IsValid()) {
-      Failed(file_error::kNotReadableErr,
+      Failed(file_error::ErrorCode::kNotReadableErr,
              FailureType::kArrayBufferBuilderCreation);
       return;
     }
@@ -253,7 +258,7 @@ void FileReaderLoader::OnReceivedData(const char* data, unsigned data_length) {
   DCHECK(data);
 
   // Bail out if we already encountered an error.
-  if (error_code_)
+  if (error_code_ != file_error::ErrorCode::kOK)
     return;
 
   if (read_type_ == kReadByClient) {
@@ -268,7 +273,8 @@ void FileReaderLoader::OnReceivedData(const char* data, unsigned data_length) {
   if (!bytes_appended) {
     raw_data_.reset();
     bytes_loaded_ = 0;
-    Failed(file_error::kNotReadableErr, FailureType::kArrayBufferBuilderAppend);
+    Failed(file_error::ErrorCode::kNotReadableErr,
+           FailureType::kArrayBufferBuilderAppend);
     return;
   }
   bytes_loaded_ += bytes_appended;
@@ -323,13 +329,15 @@ void FileReaderLoader::OnComplete(int32_t status, uint64_t data_length) {
   if (status != net::OK) {
     net_error_ = status;
     file_reader_loader_read_errors_histogram.Sample(std::max(0, -net_error_));
-    Failed(status == net::ERR_FILE_NOT_FOUND ? file_error::kNotFoundErr
-                                             : file_error::kNotReadableErr,
+    Failed(status == net::ERR_FILE_NOT_FOUND
+               ? file_error::ErrorCode::kNotFoundErr
+               : file_error::ErrorCode::kNotReadableErr,
            FailureType::kBackendReadError);
     return;
   }
   if (data_length != total_bytes_) {
-    Failed(file_error::kNotReadableErr, FailureType::kReadSizesIncorrect);
+    Failed(file_error::ErrorCode::kNotReadableErr,
+           FailureType::kReadSizesIncorrect);
     return;
   }
 
@@ -341,7 +349,7 @@ void FileReaderLoader::OnComplete(int32_t status, uint64_t data_length) {
 void FileReaderLoader::OnDataPipeReadable(MojoResult result) {
   if (result != MOJO_RESULT_OK) {
     if (!received_all_data_) {
-      Failed(file_error::kNotReadableErr,
+      Failed(file_error::ErrorCode::kNotReadableErr,
              FailureType::kDataPipeNotReadableWithBytesLeft);
     }
     return;
@@ -363,12 +371,13 @@ void FileReaderLoader::OnDataPipeReadable(MojoResult result) {
     if (result == MOJO_RESULT_FAILED_PRECONDITION) {
       // Pipe closed.
       if (!received_all_data_) {
-        Failed(file_error::kNotReadableErr, FailureType::kMojoPipeClosedEarly);
+        Failed(file_error::ErrorCode::kNotReadableErr,
+               FailureType::kMojoPipeClosedEarly);
       }
       return;
     }
     if (result != MOJO_RESULT_OK) {
-      Failed(file_error::kNotReadableErr,
+      Failed(file_error::ErrorCode::kNotReadableErr,
              FailureType::kMojoPipeUnexpectedReadError);
       return;
     }

third_party/blink/renderer/core/fileapi/file_reader_loader.h

@@ -172,7 +172,7 @@ class CORE_EXPORT FileReaderLoader : public mojom::blink::BlobReaderClient {
   int64_t memory_usage_reported_to_v8_ = 0;
 
   int32_t net_error_ = 0;  // net::OK
-  file_error::ErrorCode error_code_ = file_error::kOK;
+  file_error::ErrorCode error_code_ = file_error::ErrorCode::kOK;
 
   mojo::ScopedDataPipeConsumerHandle consumer_handle_;
   mojo::SimpleWatcher handle_watcher_;

third_party/blink/renderer/core/fileapi/file_reader_loader_client.h

@@ -32,11 +32,14 @@
 #define THIRD_PARTY_BLINK_RENDERER_CORE_FILEAPI_FILE_READER_LOADER_CLIENT_H_
 
 #include "third_party/blink/renderer/core/core_export.h"
-#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.h"
 
 namespace blink {
 
+namespace file_error {
+enum class ErrorCode;
+}
+
 class CORE_EXPORT FileReaderLoaderClient {
  public:
   virtual ~FileReaderLoaderClient() = default;

third_party/blink/renderer/core/fileapi/file_reader_sync.cc

@@ -116,7 +116,7 @@ void FileReaderSync::StartLoading(FileReaderLoader& loader,
                                   const Blob& blob,
                                   ExceptionState& exception_state) {
   loader.Start(blob.GetBlobDataHandle());
-  if (loader.GetErrorCode())
+  if (loader.GetErrorCode() != file_error::ErrorCode::kOK)
     file_error::ThrowDOMException(exception_state, loader.GetErrorCode());
 }
 

third_party/blink/renderer/modules/filesystem/file_writer.cc

@@ -33,6 +33,7 @@
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/renderer/core/events/progress_event.h"
 #include "third_party/blink/renderer/core/fileapi/blob.h"
+#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
 #include "third_party/blink/renderer/modules/filesystem/file_system_dispatcher.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
@@ -83,11 +84,11 @@ void FileWriter::write(Blob* data, ExceptionState& exception_state) {
   DCHECK(data);
   DCHECK_EQ(truncate_length_, -1);
   if (ready_state_ == kWriting) {
-    SetError(file_error::kInvalidStateErr, exception_state);
+    SetError(file_error::ErrorCode::kInvalidStateErr, exception_state);
     return;
   }
   if (recursion_depth_ > kMaxRecursionDepth) {
-    SetError(file_error::kSecurityErr, exception_state);
+    SetError(file_error::ErrorCode::kSecurityErr, exception_state);
     return;
   }
 
@@ -111,7 +112,7 @@ void FileWriter::seek(long long position, ExceptionState& exception_state) {
   if (!GetExecutionContext())
     return;
   if (ready_state_ == kWriting) {
-    SetError(file_error::kInvalidStateErr, exception_state);
+    SetError(file_error::ErrorCode::kInvalidStateErr, exception_state);
     return;
   }
 
@@ -125,11 +126,11 @@ void FileWriter::truncate(long long position, ExceptionState& exception_state) {
     return;
   DCHECK_EQ(truncate_length_, -1);
   if (ready_state_ == kWriting || position < 0) {
-    SetError(file_error::kInvalidStateErr, exception_state);
+    SetError(file_error::ErrorCode::kInvalidStateErr, exception_state);
     return;
   }
   if (recursion_depth_ > kMaxRecursionDepth) {
-    SetError(file_error::kSecurityErr, exception_state);
+    SetError(file_error::ErrorCode::kSecurityErr, exception_state);
     return;
   }
 
@@ -319,7 +320,7 @@ void FileWriter::FireEvent(const AtomicString& type) {
 
 void FileWriter::SetError(file_error::ErrorCode error_code,
                           ExceptionState& exception_state) {
-  DCHECK(error_code);
+  DCHECK_NE(error_code, file_error::ErrorCode::kOK);
   file_error::ThrowDOMException(exception_state, error_code);
   error_ = file_error::CreateDOMException(error_code);
 }

third_party/blink/renderer/modules/filesystem/file_writer.h

@@ -34,14 +34,18 @@
 #include "third_party/blink/renderer/bindings/core/v8/active_script_wrappable.h"
 #include "third_party/blink/renderer/core/dom/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
-#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
 #include "third_party/blink/renderer/modules/filesystem/file_writer_base.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
 namespace blink {
 
+namespace file_error {
+enum class ErrorCode;
+}
+
 class Blob;
+class DOMException;
 class ExceptionState;
 class ExecutionContext;
 

third_party/blink/renderer/modules/presentation/presentation_connection.cc

@@ -10,6 +10,7 @@
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/events/event.h"
 #include "third_party/blink/renderer/core/events/message_event.h"
+#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/core/fileapi/file_reader_loader.h"
 #include "third_party/blink/renderer/core/fileapi/file_reader_loader_client.h"
 #include "third_party/blink/renderer/core/frame/deprecation.h"

third_party/blink/renderer/modules/presentation/presentation_connection.h

@@ -11,7 +11,6 @@
 #include "third_party/blink/renderer/core/dom/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/core/dom/events/event_target.h"
 #include "third_party/blink/renderer/core/fileapi/blob.h"
-#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/core/typed_arrays/array_buffer_view_helpers.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
@@ -23,6 +22,10 @@ class AtomicString;
 
 namespace blink {
 
+namespace file_error {
+enum class ErrorCode;
+}
+
 class DOMArrayBuffer;
 class DOMArrayBufferView;
 class PresentationController;

third_party/blink/renderer/modules/websockets/websocket_channel_impl.cc

@@ -41,6 +41,7 @@
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/public/platform/websocket_handshake_throttle.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
+#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/core/fileapi/file_reader_loader.h"
 #include "third_party/blink/renderer/core/fileapi/file_reader_loader_client.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
@@ -769,13 +770,13 @@ void WebSocketChannelImpl::DidFinishLoadingBlob(DOMArrayBuffer* buffer) {
 void WebSocketChannelImpl::DidFailLoadingBlob(
     file_error::ErrorCode error_code) {
   blob_loader_.Clear();
-  if (error_code == file_error::kAbortErr) {
+  if (error_code == file_error::ErrorCode::kAbortErr) {
     // The error is caused by cancel().
     return;
   }
   // FIXME: Generate human-friendly reason message.
   FailAsError("Failed to load Blob: error code = " +
-              String::Number(error_code));
+              String::Number(static_cast<unsigned>(error_code)));
 }
 
 void WebSocketChannelImpl::TearDownFailedConnection() {

third_party/blink/renderer/modules/websockets/websocket_channel_impl.h

@@ -39,7 +39,6 @@
 #include "third_party/blink/public/platform/web_callbacks.h"
 #include "third_party/blink/renderer/bindings/core/v8/source_location.h"
 #include "third_party/blink/renderer/core/fileapi/blob.h"
-#include "third_party/blink/renderer/core/fileapi/file_error.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/modules/websockets/websocket_channel.h"
 #include "third_party/blink/renderer/modules/websockets/websocket_handle.h"
@@ -55,6 +54,10 @@
 
 namespace blink {
 
+namespace file_error {
+enum class ErrorCode;
+}
+
 class BaseFetchContext;
 class WebSocketChannelClient;
 class WebSocketHandshakeThrottle;