BASELINE: Update Chromium to 72.0.3626.110 and Ninja to 1.9.0

Change-Id: Ic57220b00ecc929a893c91f5cc552f5d3e99e922
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

19 files changed, 180 insertions, 167 deletions

diff --git a/chromium/third_party/blink/renderer/core/fileapi/blob.cc b/chromium/third_party/blink/renderer/core/fileapi/blob.cc
index 87c33867bc0..494a2b31ed1 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/blob.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/blob.cc
@@ -84,17 +84,17 @@ Blob::~Blob() = default;
 Blob* Blob::Create(
     ExecutionContext* context,
     const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>& blob_parts,
-    const BlobPropertyBag& options,
+    const BlobPropertyBag* options,
     ExceptionState& exception_state) {
-  DCHECK(options.hasType());
+  DCHECK(options->hasType());
 
-  DCHECK(options.hasEndings());
-  bool normalize_line_endings_to_native = options.endings() == "native";
+  DCHECK(options->hasEndings());
+  bool normalize_line_endings_to_native = (options->endings() == "native");
   if (normalize_line_endings_to_native)
     UseCounter::Count(context, WebFeature::kFileAPINativeLineEndings);
 
   std::unique_ptr<BlobData> blob_data = BlobData::Create();
-  blob_data->SetContentType(NormalizeType(options.type()));
+  blob_data->SetContentType(NormalizeType(options->type()));
 
   PopulateBlobData(blob_data.get(), blob_parts,
                    normalize_line_endings_to_native);
diff --git a/chromium/third_party/blink/renderer/core/fileapi/blob.h b/chromium/third_party/blink/renderer/core/fileapi/blob.h
index 2173f64c1f5..e02dabae0ef 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/blob.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/blob.h
@@ -62,7 +62,7 @@ class CORE_EXPORT Blob : public ScriptWrappable,
   static Blob* Create(
       ExecutionContext*,
       const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>&,
-      const BlobPropertyBag&,
+      const BlobPropertyBag*,
       ExceptionState&);
 
   static Blob* Create(scoped_refptr<BlobDataHandle> blob_data_handle) {
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file.cc b/chromium/third_party/blink/renderer/core/fileapi/file.cc
index 01df3889651..22cfc7837f4 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/file.cc
@@ -126,22 +126,22 @@ File* File::Create(
     ExecutionContext* context,
     const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>& file_bits,
     const String& file_name,
-    const FilePropertyBag& options,
+    const FilePropertyBag* options,
     ExceptionState& exception_state) {
-  DCHECK(options.hasType());
+  DCHECK(options->hasType());
 
   double last_modified;
-  if (options.hasLastModified())
-    last_modified = static_cast<double>(options.lastModified());
+  if (options->hasLastModified())
+    last_modified = static_cast<double>(options->lastModified());
   else
     last_modified = CurrentTimeMS();
-  DCHECK(options.hasEndings());
-  bool normalize_line_endings_to_native = options.endings() == "native";
+  DCHECK(options->hasEndings());
+  bool normalize_line_endings_to_native = options->endings() == "native";
   if (normalize_line_endings_to_native)
     UseCounter::Count(context, WebFeature::kFileAPINativeLineEndings);
 
   std::unique_ptr<BlobData> blob_data = BlobData::Create();
-  blob_data->SetContentType(NormalizeType(options.type()));
+  blob_data->SetContentType(NormalizeType(options->type()));
   PopulateBlobData(blob_data.get(), file_bits,
                    normalize_line_endings_to_native);
 
@@ -152,7 +152,8 @@ File* File::Create(
 
 File* File::CreateWithRelativePath(const String& path,
                                    const String& relative_path) {
-  File* file = new File(path, File::kAllContentTypes, File::kIsUserVisible);
+  File* file = MakeGarbageCollected<File>(path, File::kAllContentTypes,
+                                          File::kIsUserVisible);
   file->relative_path_ = relative_path;
   return file;
 }
@@ -248,7 +249,7 @@ File::File(const File& other)
       relative_path_(other.relative_path_) {}
 
 File* File::Clone(const String& name) const {
-  File* file = new File(*this);
+  File* file = MakeGarbageCollected<File>(*this);
   if (!name.IsNull())
     file->name_ = name;
   return file;
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file.h b/chromium/third_party/blink/renderer/core/fileapi/file.h
index 39831f1902c..2ca09ab8903 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/file.h
@@ -62,18 +62,19 @@ class CORE_EXPORT File final : public Blob {
       ExecutionContext*,
       const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>&,
       const String& file_name,
-      const FilePropertyBag&,
+      const FilePropertyBag*,
       ExceptionState&);
 
   static File* Create(const String& path,
                       ContentTypeLookupPolicy policy = kWellKnownContentTypes) {
-    return new File(path, policy, File::kIsUserVisible);
+    return MakeGarbageCollected<File>(path, policy, File::kIsUserVisible);
   }
 
   static File* Create(const String& name,
                       double modification_time,
                       scoped_refptr<BlobDataHandle> blob_data_handle) {
-    return new File(name, modification_time, std::move(blob_data_handle));
+    return MakeGarbageCollected<File>(name, modification_time,
+                                      std::move(blob_data_handle));
   }
 
   // For deserialization.
@@ -86,9 +87,9 @@ class CORE_EXPORT File final : public Blob {
       uint64_t size,
       double last_modified,
       scoped_refptr<BlobDataHandle> blob_data_handle) {
-    return new File(path, name, relative_path, user_visibility,
-                    has_snapshot_data, size, last_modified,
-                    std::move(blob_data_handle));
+    return MakeGarbageCollected<File>(
+        path, name, relative_path, user_visibility, has_snapshot_data, size,
+        last_modified, std::move(blob_data_handle));
   }
   static File* CreateFromIndexedSerialization(
       const String& path,
@@ -96,8 +97,9 @@ class CORE_EXPORT File final : public Blob {
       uint64_t size,
       double last_modified,
       scoped_refptr<BlobDataHandle> blob_data_handle) {
-    return new File(path, name, String(), kIsNotUserVisible, true, size,
-                    last_modified, std::move(blob_data_handle));
+    return MakeGarbageCollected<File>(path, name, String(), kIsNotUserVisible,
+                                      true, size, last_modified,
+                                      std::move(blob_data_handle));
   }
 
   static File* CreateWithRelativePath(const String& path,
@@ -112,15 +114,35 @@ class CORE_EXPORT File final : public Blob {
   static File* CreateForFileSystemFile(const String& name,
                                        const FileMetadata& metadata,
                                        UserVisibility user_visibility) {
-    return new File(name, metadata, user_visibility);
+    return MakeGarbageCollected<File>(name, metadata, user_visibility);
   }
 
   static File* CreateForFileSystemFile(const KURL& url,
                                        const FileMetadata& metadata,
                                        UserVisibility user_visibility) {
-    return new File(url, metadata, user_visibility);
+    return MakeGarbageCollected<File>(url, metadata, user_visibility);
   }
 
+  File(const String& path, ContentTypeLookupPolicy, UserVisibility);
+  File(const String& path,
+       const String& name,
+       ContentTypeLookupPolicy,
+       UserVisibility);
+  File(const String& path,
+       const String& name,
+       const String& relative_path,
+       UserVisibility,
+       bool has_snapshot_data,
+       uint64_t size,
+       double last_modified,
+       scoped_refptr<BlobDataHandle>);
+  File(const String& name,
+       double modification_time,
+       scoped_refptr<BlobDataHandle>);
+  File(const String& name, const FileMetadata&, UserVisibility);
+  File(const KURL& file_system_url, const FileMetadata&, UserVisibility);
+  File(const File&);
+
   KURL FileSystemURL() const {
 #if DCHECK_IS_ON()
     DCHECK(HasValidFileSystemURL());
@@ -132,10 +154,12 @@ class CORE_EXPORT File final : public Blob {
   // associated DOM properties) that differs from the one provided in the path.
   static File* CreateForUserProvidedFile(const String& path,
                                          const String& display_name) {
-    if (display_name.IsEmpty())
-      return new File(path, File::kAllContentTypes, File::kIsUserVisible);
-    return new File(path, display_name, File::kAllContentTypes,
-                    File::kIsUserVisible);
+    if (display_name.IsEmpty()) {
+      return MakeGarbageCollected<File>(path, File::kAllContentTypes,
+                                        File::kIsUserVisible);
+    }
+    return MakeGarbageCollected<File>(
+        path, display_name, File::kAllContentTypes, File::kIsUserVisible);
   }
 
   static File* CreateForFileSystemFile(
@@ -143,8 +167,9 @@ class CORE_EXPORT File final : public Blob {
       const String& name,
       ContentTypeLookupPolicy policy = kWellKnownContentTypes) {
     if (name.IsEmpty())
-      return new File(path, policy, File::kIsNotUserVisible);
-    return new File(path, name, policy, File::kIsNotUserVisible);
+      return MakeGarbageCollected<File>(path, policy, File::kIsNotUserVisible);
+    return MakeGarbageCollected<File>(path, name, policy,
+                                      File::kIsNotUserVisible);
   }
 
   File* Clone(const String& name = String()) const;
@@ -196,26 +221,6 @@ class CORE_EXPORT File final : public Blob {
   bool HasSameSource(const File& other) const;
 
  private:
-  File(const String& path, ContentTypeLookupPolicy, UserVisibility);
-  File(const String& path,
-       const String& name,
-       ContentTypeLookupPolicy,
-       UserVisibility);
-  File(const String& path,
-       const String& name,
-       const String& relative_path,
-       UserVisibility,
-       bool has_snapshot_data,
-       uint64_t size,
-       double last_modified,
-       scoped_refptr<BlobDataHandle>);
-  File(const String& name,
-       double modification_time,
-       scoped_refptr<BlobDataHandle>);
-  File(const String& name, const FileMetadata&, UserVisibility);
-  File(const KURL& file_system_url, const FileMetadata&, UserVisibility);
-  File(const File&);
-
   void InvalidateSnapshotMetadata() { snapshot_size_ = -1; }
 
   // Returns File's last modified time (in MS since Epoch.)
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_error.cc b/chromium/third_party/blink/renderer/core/fileapi/file_error.cc
index a0d08edc7da..4fbca6770cf 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_error.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_error.cc
@@ -36,7 +36,7 @@
 
 namespace blink {
 
-namespace FileError {
+namespace file_error {
 
 const char kAbortErrorMessage[] =
     "An ongoing operation was aborted, typically with a call to abort().";
@@ -72,33 +72,33 @@ const char kTypeMismatchErrorMessage[] =
 
 namespace {
 
-DOMExceptionCode ErrorCodeToExceptionCode(ErrorCode code) {
+DOMExceptionCode ErrorCodeToExceptionCode(FileErrorCode code) {
   switch (code) {
-    case kOK:
+    case FileErrorCode::kOK:
       return DOMExceptionCode::kNoError;
-    case kNotFoundErr:
+    case FileErrorCode::kNotFoundErr:
       return DOMExceptionCode::kNotFoundError;
-    case kSecurityErr:
+    case FileErrorCode::kSecurityErr:
       return DOMExceptionCode::kSecurityError;
-    case kAbortErr:
+    case FileErrorCode::kAbortErr:
       return DOMExceptionCode::kAbortError;
-    case kNotReadableErr:
+    case FileErrorCode::kNotReadableErr:
       return DOMExceptionCode::kNotReadableError;
-    case kEncodingErr:
+    case FileErrorCode::kEncodingErr:
       return DOMExceptionCode::kEncodingError;
-    case kNoModificationAllowedErr:
+    case FileErrorCode::kNoModificationAllowedErr:
       return DOMExceptionCode::kNoModificationAllowedError;
-    case kInvalidStateErr:
+    case FileErrorCode::kInvalidStateErr:
       return DOMExceptionCode::kInvalidStateError;
-    case kSyntaxErr:
+    case FileErrorCode::kSyntaxErr:
       return DOMExceptionCode::kSyntaxError;
-    case kInvalidModificationErr:
+    case FileErrorCode::kInvalidModificationErr:
       return DOMExceptionCode::kInvalidModificationError;
-    case kQuotaExceededErr:
+    case FileErrorCode::kQuotaExceededErr:
       return DOMExceptionCode::kQuotaExceededError;
-    case kTypeMismatchErr:
+    case FileErrorCode::kTypeMismatchErr:
       return DOMExceptionCode::kTypeMismatchError;
-    case kPathExistsErr:
+    case FileErrorCode::kPathExistsErr:
       return DOMExceptionCode::kPathExistsError;
     default:
       NOTREACHED();
@@ -106,35 +106,35 @@ DOMExceptionCode ErrorCodeToExceptionCode(ErrorCode code) {
   }
 }
 
-const char* ErrorCodeToMessage(ErrorCode code) {
+const char* ErrorCodeToMessage(FileErrorCode 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 FileErrorCode::kOK:
       return nullptr;
-    case kSecurityErr:
+    case FileErrorCode::kSecurityErr:
       return kSecurityErrorMessage;
-    case kNotFoundErr:
+    case FileErrorCode::kNotFoundErr:
       return kNotFoundErrorMessage;
-    case kAbortErr:
+    case FileErrorCode::kAbortErr:
       return kAbortErrorMessage;
-    case kNotReadableErr:
+    case FileErrorCode::kNotReadableErr:
       return kNotReadableErrorMessage;
-    case kEncodingErr:
+    case FileErrorCode::kEncodingErr:
       return kEncodingErrorMessage;
-    case kNoModificationAllowedErr:
+    case FileErrorCode::kNoModificationAllowedErr:
       return kNoModificationAllowedErrorMessage;
-    case kInvalidStateErr:
+    case FileErrorCode::kInvalidStateErr:
       return kInvalidStateErrorMessage;
-    case kSyntaxErr:
+    case FileErrorCode::kSyntaxErr:
       return kSyntaxErrorMessage;
-    case kInvalidModificationErr:
+    case FileErrorCode::kInvalidModificationErr:
       return nullptr;
-    case kQuotaExceededErr:
+    case FileErrorCode::kQuotaExceededErr:
       return kQuotaExceededErrorMessage;
-    case kTypeMismatchErr:
+    case FileErrorCode::kTypeMismatchErr:
       return nullptr;
-    case kPathExistsErr:
+    case FileErrorCode::kPathExistsErr:
       return kPathExistsErrorMessage;
     default:
       NOTREACHED();
@@ -229,14 +229,14 @@ const char* FileErrorToMessage(base::File::Error code) {
 }  // namespace
 
 void ThrowDOMException(ExceptionState& exception_state,
-                       ErrorCode code,
+                       FileErrorCode code,
                        String message) {
-  if (code == kOK)
+  if (code == FileErrorCode::kOK)
     return;
 
   // SecurityError is special-cased, as we want to route those exceptions
   // through ExceptionState::ThrowSecurityError.
-  if (code == kSecurityErr) {
+  if (code == FileErrorCode::kSecurityErr) {
     exception_state.ThrowSecurityError(kSecurityErrorMessage);
     return;
   }
@@ -268,8 +268,8 @@ void ThrowDOMException(ExceptionState& exception_state,
   exception_state.ThrowDOMException(FileErrorToExceptionCode(error), message);
 }
 
-DOMException* CreateDOMException(ErrorCode code) {
-  DCHECK_NE(code, kOK);
+DOMException* CreateDOMException(FileErrorCode code) {
+  DCHECK_NE(code, FileErrorCode::kOK);
   return DOMException::Create(ErrorCodeToExceptionCode(code),
                               ErrorCodeToMessage(code));
 }
@@ -280,6 +280,6 @@ DOMException* CreateDOMException(base::File::Error code) {
                               FileErrorToMessage(code));
 }
 
-}  // namespace FileError
+}  // namespace file_error
 
 }  // namespace blink
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_error.h b/chromium/third_party/blink/renderer/core/fileapi/file_error.h
index bea0453e8b3..ac22e5ec09e 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_error.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_error.h
@@ -40,9 +40,7 @@ namespace blink {
 class DOMException;
 class ExceptionState;
 
-namespace FileError {
-
-enum ErrorCode {
+enum class FileErrorCode {
   kOK = 0,
   kNotFoundErr = 1,
   kSecurityErr = 2,
@@ -58,6 +56,8 @@ enum ErrorCode {
   kPathExistsErr = 12,
 };
 
+namespace file_error {
+
 CORE_EXPORT extern const char kAbortErrorMessage[];
 CORE_EXPORT extern const char kEncodingErrorMessage[];
 CORE_EXPORT extern const char kInvalidStateErrorMessage[];
@@ -71,15 +71,15 @@ CORE_EXPORT extern const char kSyntaxErrorMessage[];
 CORE_EXPORT extern const char kTypeMismatchErrorMessage[];
 
 CORE_EXPORT void ThrowDOMException(ExceptionState&,
-                                   ErrorCode,
+                                   FileErrorCode,
                                    String message = String());
 CORE_EXPORT void ThrowDOMException(ExceptionState& exception_state,
                                    base::File::Error error,
                                    String message = String());
-CORE_EXPORT DOMException* CreateDOMException(ErrorCode);
+CORE_EXPORT DOMException* CreateDOMException(FileErrorCode);
 CORE_EXPORT DOMException* CreateDOMException(base::File::Error);
 
-}  // namespace FileError
+}  // namespace file_error
 
 }  // namespace blink
 
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_list.cc b/chromium/third_party/blink/renderer/core/fileapi/file_list.cc
index 720371ecba0..323cae340e2 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_list.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_list.cc
@@ -25,6 +25,8 @@
 
 #include "third_party/blink/renderer/core/fileapi/file_list.h"
 
+#include "third_party/blink/public/platform/file_path_conversion.h"
+
 namespace blink {
 
 FileList::FileList() = default;
@@ -35,14 +37,14 @@ File* FileList::item(unsigned index) const {
   return files_[index].Get();
 }
 
-Vector<String> FileList::PathsForUserVisibleFiles() const {
-  Vector<String> paths;
+Vector<base::FilePath> FileList::PathsForUserVisibleFiles() const {
+  Vector<base::FilePath> paths;
   for (unsigned i = 0; i < files_.size(); ++i) {
     if (files_[i]->GetUserVisibility() == File::kIsUserVisible) {
       if (files_[i]->HasBackingFile())
-        paths.push_back(files_[i]->GetPath());
+        paths.push_back(StringToFilePath(files_[i]->GetPath()));
       else
-        paths.push_back(files_[i]->name());
+        paths.push_back(StringToFilePath(files_[i]->name()));
     }
   }
 
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_list.h b/chromium/third_party/blink/renderer/core/fileapi/file_list.h
index 3796379d6e7..0eeec3d62ce 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_list.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_list.h
@@ -38,7 +38,9 @@ class CORE_EXPORT FileList final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static FileList* Create() { return new FileList; }
+  static FileList* Create() { return MakeGarbageCollected<FileList>(); }
+
+  FileList();
 
   unsigned length() const { return files_.size(); }
   File* item(unsigned index) const;
@@ -46,13 +48,11 @@ class CORE_EXPORT FileList final : public ScriptWrappable {
   bool IsEmpty() const { return files_.IsEmpty(); }
   void clear() { files_.clear(); }
   void Append(File* file) { files_.push_back(file); }
-  Vector<String> PathsForUserVisibleFiles() const;
+  Vector<base::FilePath> PathsForUserVisibleFiles() const;
 
   void Trace(blink::Visitor*) override;
 
  private:
-  FileList();
-
   HeapVector<Member<File>> files_;
 };
 
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_list_test.cc b/chromium/third_party/blink/renderer/core/fileapi/file_list_test.cc
index 44ac7305177..00b6b4c98c5 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_list_test.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_list_test.cc
@@ -53,12 +53,12 @@ TEST(FileListTest, pathsForUserVisibleFiles) {
                                                     File::kIsNotUserVisible));
   }
 
-  Vector<String> paths = file_list->PathsForUserVisibleFiles();
+  Vector<base::FilePath> paths = file_list->PathsForUserVisibleFiles();
 
   ASSERT_EQ(3u, paths.size());
-  EXPECT_EQ("/native/path", paths[0]);
-  EXPECT_EQ("/native/visible/snapshot", paths[1]);
-  EXPECT_EQ("visible-non-native-file", paths[2])
+  EXPECT_EQ(FILE_PATH_LITERAL("/native/path"), paths[0].value());
+  EXPECT_EQ(FILE_PATH_LITERAL("/native/visible/snapshot"), paths[1].value());
+  EXPECT_EQ(FILE_PATH_LITERAL("visible-non-native-file"), paths[2].value())
       << "Files not backed by a native file should return name.";
 }
 
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader.cc b/chromium/third_party/blink/renderer/core/fileapi/file_reader.cc
index 5e68a2739ab..7b595c43579 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader.cc
+++ b/chromium/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"
@@ -82,7 +83,7 @@ class FileReader::ThrottlingController final
     ThrottlingController* controller =
         Supplement<ExecutionContext>::From<ThrottlingController>(*context);
     if (!controller) {
-      controller = new ThrottlingController(*context);
+      controller = MakeGarbageCollected<ThrottlingController>(*context);
       ProvideTo(*context, controller);
     }
     return controller;
@@ -119,6 +120,10 @@ class FileReader::ThrottlingController final
     probe::AsyncTaskCanceled(context, reader);
   }
 
+  explicit ThrottlingController(ExecutionContext& context)
+      : Supplement<ExecutionContext>(context),
+        max_running_readers_(kMaxOutstandingRequestsPerThread) {}
+
   void Trace(blink::Visitor* visitor) override {
     visitor->Trace(pending_readers_);
     visitor->Trace(running_readers_);
@@ -126,10 +131,6 @@ class FileReader::ThrottlingController final
   }
 
  private:
-  explicit ThrottlingController(ExecutionContext& context)
-      : Supplement<ExecutionContext>(context),
-        max_running_readers_(kMaxOutstandingRequestsPerThread) {}
-
   void PushReader(FileReader* reader) {
     if (pending_readers_.IsEmpty() &&
         running_readers_.size() < max_running_readers_) {
@@ -192,7 +193,7 @@ const char FileReader::ThrottlingController::kSupplementName[] =
     "FileReaderThrottlingController";
 
 FileReader* FileReader::Create(ExecutionContext* context) {
-  return new FileReader(context);
+  return MakeGarbageCollected<FileReader>(context);
 }
 
 FileReader::FileReader(ExecutionContext* context)
@@ -208,7 +209,7 @@ FileReader::~FileReader() {
 }
 
 const AtomicString& FileReader::InterfaceName() const {
-  return EventTargetNames::FileReader;
+  return event_target_names::kFileReader;
 }
 
 void FileReader::ContextDestroyed(ExecutionContext* destroyed_context) {
@@ -337,14 +338,14 @@ void FileReader::abort() {
   base::AutoReset<bool> firing_events(&still_firing_events_, true);
 
   // Setting error implicitly makes |result| return null.
-  error_ = FileError::CreateDOMException(FileError::kAbortErr);
+  error_ = file_error::CreateDOMException(FileErrorCode::kAbortErr);
 
   // Unregister the reader.
   ThrottlingController::FinishReaderType final_step =
       ThrottlingController::RemoveReader(GetExecutionContext(), this);
 
-  FireEvent(EventTypeNames::abort);
-  FireEvent(EventTypeNames::loadend);
+  FireEvent(event_type_names::kAbort);
+  FireEvent(event_type_names::kLoadend);
 
   // All possible events have fired and we're done, no more pending activity.
   ThrottlingController::FinishReader(GetExecutionContext(), this, final_step);
@@ -382,7 +383,7 @@ void FileReader::Terminate() {
 
 void FileReader::DidStartLoading() {
   base::AutoReset<bool> firing_events(&still_firing_events_, true);
-  FireEvent(EventTypeNames::loadstart);
+  FireEvent(event_type_names::kLoadstart);
 }
 
 void FileReader::DidReceiveData() {
@@ -393,7 +394,7 @@ void FileReader::DidReceiveData() {
   } else if (now - last_progress_notification_time_ms_ >
              kProgressNotificationIntervalMS) {
     base::AutoReset<bool> firing_events(&still_firing_events_, true);
-    FireEvent(EventTypeNames::progress);
+    FireEvent(event_type_names::kProgress);
     last_progress_notification_time_ms_ = now;
   }
 }
@@ -415,7 +416,7 @@ void FileReader::DidFinishLoading() {
   // if we're still loading (therefore we need abort process) or not.
   loading_state_ = kLoadingStateNone;
 
-  FireEvent(EventTypeNames::progress);
+  FireEvent(event_type_names::kProgress);
 
   DCHECK_NE(kDone, state_);
   state_ = kDone;
@@ -424,14 +425,14 @@ void FileReader::DidFinishLoading() {
   ThrottlingController::FinishReaderType final_step =
       ThrottlingController::RemoveReader(GetExecutionContext(), this);
 
-  FireEvent(EventTypeNames::load);
-  FireEvent(EventTypeNames::loadend);
+  FireEvent(event_type_names::kLoad);
+  FireEvent(event_type_names::kLoadend);
 
   // All possible events have fired and we're done, no more pending activity.
   ThrottlingController::FinishReader(GetExecutionContext(), this, final_step);
 }
 
-void FileReader::DidFail(FileError::ErrorCode error_code) {
+void FileReader::DidFail(FileErrorCode error_code) {
   if (loading_state_ == kLoadingStateAborted)
     return;
 
@@ -443,14 +444,14 @@ void FileReader::DidFail(FileError::ErrorCode error_code) {
   DCHECK_NE(kDone, state_);
   state_ = kDone;
 
-  error_ = FileError::CreateDOMException(error_code);
+  error_ = file_error::CreateDOMException(error_code);
 
   // Unregister the reader.
   ThrottlingController::FinishReaderType final_step =
       ThrottlingController::RemoveReader(GetExecutionContext(), this);
 
-  FireEvent(EventTypeNames::error);
-  FireEvent(EventTypeNames::loadend);
+  FireEvent(event_type_names::kError);
+  FireEvent(event_type_names::kLoadend);
 
   // All possible events have fired and we're done, no more pending activity.
   ThrottlingController::FinishReader(GetExecutionContext(), this, final_step);
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader.h b/chromium/third_party/blink/renderer/core/fileapi/file_reader.h
index 94649ffc368..7c5cfd40127 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader.h
+++ b/chromium/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"
@@ -47,6 +46,7 @@ namespace blink {
 class Blob;
 class ExceptionState;
 class ExecutionContext;
+enum class FileErrorCode;
 class StringOrArrayBuffer;
 
 class CORE_EXPORT FileReader final : public EventTargetWithInlineData,
@@ -59,6 +59,7 @@ class CORE_EXPORT FileReader final : public EventTargetWithInlineData,
  public:
   static FileReader* Create(ExecutionContext*);
 
+  explicit FileReader(ExecutionContext*);
   ~FileReader() override;
 
   enum ReadyState { kEmpty = 0, kLoading = 1, kDone = 2 };
@@ -90,22 +91,20 @@ class CORE_EXPORT FileReader final : public EventTargetWithInlineData,
   void DidStartLoading() override;
   void DidReceiveData() override;
   void DidFinishLoading() override;
-  void DidFail(FileError::ErrorCode) override;
+  void DidFail(FileErrorCode) override;
 
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(loadstart);
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(progress);
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(load);
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(loadend);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(loadstart, kLoadstart);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(progress, kProgress);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(load, kLoad);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(abort, kAbort);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(error, kError);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(loadend, kLoadend);
 
   void Trace(blink::Visitor*) override;
 
  private:
   class ThrottlingController;
 
-  explicit FileReader(ExecutionContext*);
-
   void Terminate();
   void ReadInternal(Blob*, FileReaderLoader::ReadType, ExceptionState&);
   void FireEvent(const AtomicString& type);
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.cc b/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.cc
index 173a43dfbd0..5a1cc40c235 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.cc
@@ -100,7 +100,7 @@ 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(FileError::kNotReadableErr, FailureType::kMojoPipeCreation);
+    Failed(FileErrorCode::kNotReadableErr, FailureType::kMojoPipeCreation);
     return;
   }
 
@@ -115,21 +115,22 @@ void FileReaderLoader::Start(scoped_refptr<BlobDataHandle> blob_data) {
     if (received_on_complete_)
       return;
     if (!received_all_data_) {
-      Failed(FileError::kNotReadableErr, FailureType::kSyncDataNotAllLoaded);
+      Failed(FileErrorCode::kNotReadableErr,
+             FailureType::kSyncDataNotAllLoaded);
       return;
     }
 
     // Wait for OnComplete
     binding_.WaitForIncomingMethodCall();
     if (!received_on_complete_) {
-      Failed(FileError::kNotReadableErr,
+      Failed(FileErrorCode::kNotReadableErr,
              FailureType::kSyncOnCompleteNotReceived);
     }
   }
 }
 
 void FileReaderLoader::Cancel() {
-  error_code_ = FileError::kAbortErr;
+  error_code_ = FileErrorCode::kAbortErr;
   Cleanup();
 }
 
@@ -139,7 +140,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_ != FileErrorCode::kOK)
     return nullptr;
 
   DOMArrayBuffer* result = DOMArrayBuffer::Create(raw_data_->ToArrayBuffer());
@@ -156,8 +157,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_ != FileErrorCode::kOK) ||
+      is_raw_data_converted_) {
     return string_result_;
+  }
 
   switch (read_type_) {
     case kReadAsArrayBuffer:
@@ -197,7 +200,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_ != FileErrorCode::kOK) {
     raw_data_.reset();
     string_result_ = "";
     is_raw_data_converted_ = true;
@@ -207,13 +210,12 @@ void FileReaderLoader::Cleanup() {
   }
 }
 
-void FileReaderLoader::Failed(FileError::ErrorCode error_code,
-                              FailureType type) {
+void FileReaderLoader::Failed(FileErrorCode error_code, FailureType type) {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, failure_histogram,
                                   ("Storage.Blob.FileReaderLoader.FailureType",
                                    static_cast<int>(FailureType::kCount)));
   // If an error was already reported, don't report this error again.
-  if (error_code_ != FileError::kOK)
+  if (error_code_ != FileErrorCode::kOK)
     return;
   error_code_ = error_code;
   failure_histogram.Count(static_cast<int>(type));
@@ -232,13 +234,13 @@ 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(FileError::kNotReadableErr, FailureType::kTotalBytesTooLarge);
+      Failed(FileErrorCode::kNotReadableErr, FailureType::kTotalBytesTooLarge);
       return;
     }
 
     raw_data_ = std::make_unique<ArrayBufferBuilder>(total_bytes);
     if (!raw_data_->IsValid()) {
-      Failed(FileError::kNotReadableErr,
+      Failed(FileErrorCode::kNotReadableErr,
              FailureType::kArrayBufferBuilderCreation);
       return;
     }
@@ -253,7 +255,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_ != FileErrorCode::kOK)
     return;
 
   if (read_type_ == kReadByClient) {
@@ -268,7 +270,8 @@ void FileReaderLoader::OnReceivedData(const char* data, unsigned data_length) {
   if (!bytes_appended) {
     raw_data_.reset();
     bytes_loaded_ = 0;
-    Failed(FileError::kNotReadableErr, FailureType::kArrayBufferBuilderAppend);
+    Failed(FileErrorCode::kNotReadableErr,
+           FailureType::kArrayBufferBuilderAppend);
     return;
   }
   bytes_loaded_ += bytes_appended;
@@ -323,13 +326,13 @@ 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 ? FileError::kNotFoundErr
-                                             : FileError::kNotReadableErr,
+    Failed(status == net::ERR_FILE_NOT_FOUND ? FileErrorCode::kNotFoundErr
+                                             : FileErrorCode::kNotReadableErr,
            FailureType::kBackendReadError);
     return;
   }
   if (data_length != total_bytes_) {
-    Failed(FileError::kNotReadableErr, FailureType::kReadSizesIncorrect);
+    Failed(FileErrorCode::kNotReadableErr, FailureType::kReadSizesIncorrect);
     return;
   }
 
@@ -341,7 +344,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(FileError::kNotReadableErr,
+      Failed(FileErrorCode::kNotReadableErr,
              FailureType::kDataPipeNotReadableWithBytesLeft);
     }
     return;
@@ -363,12 +366,13 @@ void FileReaderLoader::OnDataPipeReadable(MojoResult result) {
     if (result == MOJO_RESULT_FAILED_PRECONDITION) {
       // Pipe closed.
       if (!received_all_data_) {
-        Failed(FileError::kNotReadableErr, FailureType::kMojoPipeClosedEarly);
+        Failed(FileErrorCode::kNotReadableErr,
+               FailureType::kMojoPipeClosedEarly);
       }
       return;
     }
     if (result != MOJO_RESULT_OK) {
-      Failed(FileError::kNotReadableErr,
+      Failed(FileErrorCode::kNotReadableErr,
              FailureType::kMojoPipeUnexpectedReadError);
       return;
     }
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.h b/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.h
index 6eeccfd2d55..9f238c8732d 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader.h
@@ -97,7 +97,7 @@ class CORE_EXPORT FileReaderLoader : public mojom::blink::BlobReaderClient {
   // After OnCalculatedSize() is called: Returns the size of the resource.
   base::Optional<uint64_t> TotalBytes() const { return total_bytes_; }
 
-  FileError::ErrorCode GetErrorCode() const { return error_code_; }
+  FileErrorCode GetErrorCode() const { return error_code_; }
 
   int32_t GetNetError() const { return net_error_; }
 
@@ -128,7 +128,7 @@ class CORE_EXPORT FileReaderLoader : public mojom::blink::BlobReaderClient {
   };
 
   void Cleanup();
-  void Failed(FileError::ErrorCode, FailureType type);
+  void Failed(FileErrorCode, FailureType type);
 
   void OnStartLoading(uint64_t total_bytes);
   void OnReceivedData(const char* data, unsigned data_length);
@@ -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
-  FileError::ErrorCode error_code_ = FileError::kOK;
+  FileErrorCode error_code_ = FileErrorCode::kOK;
 
   mojo::ScopedDataPipeConsumerHandle consumer_handle_;
   mojo::SimpleWatcher handle_watcher_;
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader_client.h b/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader_client.h
index d52508fbbd3..747a254d098 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader_client.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_reader_loader_client.h
@@ -32,11 +32,12 @@
 #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 {
 
+enum class FileErrorCode;
+
 class CORE_EXPORT FileReaderLoaderClient {
  public:
   virtual ~FileReaderLoaderClient() = default;
@@ -51,7 +52,7 @@ class CORE_EXPORT FileReaderLoaderClient {
     NOTREACHED();
   }
   virtual void DidFinishLoading() = 0;
-  virtual void DidFail(FileError::ErrorCode) = 0;
+  virtual void DidFail(FileErrorCode) = 0;
 };
 
 }  // namespace blink
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.cc b/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.cc
index ebd429f6a8e..4357025cfce 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.cc
@@ -116,8 +116,8 @@ void FileReaderSync::StartLoading(FileReaderLoader& loader,
                                   const Blob& blob,
                                   ExceptionState& exception_state) {
   loader.Start(blob.GetBlobDataHandle());
-  if (loader.GetErrorCode())
-    FileError::ThrowDOMException(exception_state, loader.GetErrorCode());
+  if (loader.GetErrorCode() != FileErrorCode::kOK)
+    file_error::ThrowDOMException(exception_state, loader.GetErrorCode());
 }
 
 }  // namespace blink
diff --git a/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.h b/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.h
index d5db3fca225..2c93cb71614 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/file_reader_sync.h
@@ -48,9 +48,11 @@ class FileReaderSync final : public ScriptWrappable {
 
  public:
   static FileReaderSync* Create(ExecutionContext* context) {
-    return new FileReaderSync(context);
+    return MakeGarbageCollected<FileReaderSync>(context);
   }
 
+  explicit FileReaderSync(ExecutionContext*);
+
   DOMArrayBuffer* readAsArrayBuffer(Blob*, ExceptionState&);
   String readAsBinaryString(Blob*, ExceptionState&);
   String readAsText(Blob* blob, ExceptionState& ec) {
@@ -60,8 +62,6 @@ class FileReaderSync final : public ScriptWrappable {
   String readAsDataURL(Blob*, ExceptionState&);
 
  private:
-  explicit FileReaderSync(ExecutionContext*);
-
   void StartLoading(FileReaderLoader&, const Blob&, ExceptionState&);
 };
 
diff --git a/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.cc b/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.cc
index 8c54d944a3d..e3de27cfe89 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.cc
@@ -100,7 +100,7 @@ SecurityOrigin* BlobOriginMap::GetOrigin(const KURL& url) {
 }  // namespace
 
 PublicURLManager* PublicURLManager::Create(ExecutionContext* context) {
-  return new PublicURLManager(context);
+  return MakeGarbageCollected<PublicURLManager>(context);
 }
 
 PublicURLManager::PublicURLManager(ExecutionContext* context)
diff --git a/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.h b/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.h
index 26c71d7c913..7c808b2dd83 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.h
+++ b/chromium/third_party/blink/renderer/core/fileapi/public_url_manager.h
@@ -50,6 +50,8 @@ class CORE_EXPORT PublicURLManager final
  public:
   static PublicURLManager* Create(ExecutionContext*);
 
+  explicit PublicURLManager(ExecutionContext*);
+
   // Generates a new Blob URL and registers the URLRegistrable to the
   // corresponding URLRegistry with the Blob URL. Returns the serialization
   // of the Blob URL.
@@ -76,8 +78,6 @@ class CORE_EXPORT PublicURLManager final
   }
 
  private:
-  explicit PublicURLManager(ExecutionContext*);
-
   typedef String URLString;
   // Map from URLs to the URLRegistry they are registered with.
   typedef HashMap<URLString, URLRegistry*> URLToRegistryMap;
diff --git a/chromium/third_party/blink/renderer/core/fileapi/public_url_manager_test.cc b/chromium/third_party/blink/renderer/core/fileapi/public_url_manager_test.cc
index 77ab63eba0e..0eb443d6357 100644
--- a/chromium/third_party/blink/renderer/core/fileapi/public_url_manager_test.cc
+++ b/chromium/third_party/blink/renderer/core/fileapi/public_url_manager_test.cc
@@ -72,7 +72,7 @@ class PublicURLManagerTest : public testing::Test {
   void SetUp() override {
     scoped_feature_list_.InitAndEnableFeature(features::kMojoBlobURLs);
 
-    execution_context_ = new NullExecutionContext;
+    execution_context_ = MakeGarbageCollected<NullExecutionContext>();
     // By default this creates a unique origin, which is exactly what this test
     // wants.
     execution_context_->SetUpSecurityContext();