BASELINE: Update Chromium to 51.0.2704.41

Also adds in all smaller components by reversing logic for exclusion.

Change-Id: Ibf90b506e7da088ea2f65dcf23f2b0992c504422
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>

1 files changed, 174 insertions, 0 deletions

diff --git a/chromium/components/filesystem/util.cc b/chromium/components/filesystem/util.cc
new file mode 100644
index 00000000000..16bef002183
--- /dev/null
+++ b/chromium/components/filesystem/util.cc
@@ -0,0 +1,174 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/filesystem/util.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include <limits>
+
+#include "base/logging.h"
+#include "base/strings/string_util.h"
+#include "build/build_config.h"
+#include "mojo/public/cpp/bindings/string.h"
+
+#if defined(OS_WIN)
+#include "base/strings/utf_string_conversions.h"
+#endif
+
+// module filesystem has various constants which must line up with enum values
+// in base::File::Flags.
+static_assert(filesystem::kFlagOpen ==
+                  static_cast<uint32_t>(base::File::FLAG_OPEN),
+              "");
+static_assert(filesystem::kFlagCreate ==
+                  static_cast<uint32_t>(base::File::FLAG_CREATE),
+              "");
+static_assert(filesystem::kFlagOpenAlways ==
+                  static_cast<uint32_t>(base::File::FLAG_OPEN_ALWAYS),
+              "");
+static_assert(filesystem::kCreateAlways ==
+                  static_cast<uint32_t>(base::File::FLAG_CREATE_ALWAYS),
+              "");
+static_assert(filesystem::kFlagOpenTruncated ==
+                  static_cast<uint32_t>(base::File::FLAG_OPEN_TRUNCATED),
+              "");
+static_assert(filesystem::kFlagRead ==
+                  static_cast<uint32_t>(base::File::FLAG_READ),
+              "");
+static_assert(filesystem::kFlagWrite ==
+                  static_cast<uint32_t>(base::File::FLAG_WRITE),
+              "");
+static_assert(filesystem::kFlagAppend ==
+                  static_cast<uint32_t>(base::File::FLAG_APPEND),
+              "");
+
+// filesystem.Error in types.mojom must be the same as base::File::Error.
+static_assert(static_cast<int>(filesystem::FileError::OK) ==
+                  static_cast<int>(base::File::FILE_OK),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::FAILED) ==
+                  static_cast<int>(base::File::FILE_ERROR_FAILED),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::IN_USE) ==
+                  static_cast<int>(base::File::FILE_ERROR_IN_USE),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::EXISTS) ==
+                  static_cast<int>(base::File::FILE_ERROR_EXISTS),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::NOT_FOUND) ==
+                  static_cast<int>(base::File::FILE_ERROR_NOT_FOUND),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::ACCESS_DENIED) ==
+                  static_cast<int>(base::File::FILE_ERROR_ACCESS_DENIED),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::TOO_MANY_OPENED) ==
+                  static_cast<int>(base::File::FILE_ERROR_TOO_MANY_OPENED),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::NO_MEMORY) ==
+                  static_cast<int>(base::File::FILE_ERROR_NO_MEMORY),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::NO_SPACE) ==
+                  static_cast<int>(base::File::FILE_ERROR_NO_SPACE),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::NOT_A_DIRECTORY) ==
+                  static_cast<int>(base::File::FILE_ERROR_NOT_A_DIRECTORY),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::INVALID_OPERATION) ==
+                  static_cast<int>(base::File::FILE_ERROR_INVALID_OPERATION),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::SECURITY) ==
+                  static_cast<int>(base::File::FILE_ERROR_SECURITY),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::ABORT) ==
+                  static_cast<int>(base::File::FILE_ERROR_ABORT),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::NOT_A_FILE) ==
+                  static_cast<int>(base::File::FILE_ERROR_NOT_A_FILE),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::NOT_EMPTY) ==
+                  static_cast<int>(base::File::FILE_ERROR_NOT_EMPTY),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::INVALID_URL) ==
+                  static_cast<int>(base::File::FILE_ERROR_INVALID_URL),
+              "");
+static_assert(static_cast<int>(filesystem::FileError::IO) ==
+                  static_cast<int>(base::File::FILE_ERROR_IO),
+              "");
+
+// filesystem.Whence in types.mojom must be the same as base::File::Whence.
+static_assert(static_cast<int>(filesystem::Whence::FROM_BEGIN) ==
+                  static_cast<int>(base::File::FROM_BEGIN),
+              "");
+static_assert(static_cast<int>(filesystem::Whence::FROM_CURRENT) ==
+                  static_cast<int>(base::File::FROM_CURRENT),
+              "");
+static_assert(static_cast<int>(filesystem::Whence::FROM_END) ==
+                  static_cast<int>(base::File::FROM_END),
+              "");
+
+namespace filesystem {
+
+FileError IsWhenceValid(Whence whence) {
+  return (whence == Whence::FROM_CURRENT || whence == Whence::FROM_BEGIN ||
+          whence == Whence::FROM_END)
+             ? FileError::OK
+             : FileError::INVALID_OPERATION;
+}
+
+FileError IsOffsetValid(int64_t offset) {
+  return (offset >= std::numeric_limits<off_t>::min() &&
+          offset <= std::numeric_limits<off_t>::max())
+             ? FileError::OK
+             : FileError::INVALID_OPERATION;
+}
+
+FileError GetError(const base::File& file) {
+  return static_cast<filesystem::FileError>(file.error_details());
+}
+
+FileInformationPtr MakeFileInformation(const base::File::Info& info) {
+  FileInformationPtr file_info(FileInformation::New());
+  file_info->type =
+      info.is_directory ? FsFileType::DIRECTORY : FsFileType::REGULAR_FILE;
+  file_info->size = info.size;
+
+  file_info->atime = info.last_accessed.ToDoubleT();
+  file_info->mtime = info.last_modified.ToDoubleT();
+  file_info->ctime = info.creation_time.ToDoubleT();
+
+  return file_info;
+}
+
+FileError ValidatePath(const mojo::String& raw_path,
+                       const base::FilePath& filesystem_base,
+                       base::FilePath* out) {
+  DCHECK(!raw_path.is_null());
+  if (!base::IsStringUTF8(raw_path.get()))
+    return FileError::INVALID_OPERATION;
+
+#if defined(OS_POSIX)
+  base::FilePath::StringType path = raw_path;
+#elif defined(OS_WIN)
+  base::FilePath::StringType path = base::UTF8ToUTF16(raw_path.get());
+#endif
+
+  // TODO(erg): This isn't really what we want. FilePath::AppendRelativePath()
+  // is closer. We need to deal with entirely hostile apps trying to bust this
+  // function to use a possibly maliciously provided |raw_path| to bust out of
+  // |filesystem_base|.
+  base::FilePath full_path = filesystem_base.Append(path);
+  if (full_path.ReferencesParent()) {
+    // TODO(erg): For now, if it references a parent, we'll consider this bad.
+    return FileError::ACCESS_DENIED;
+  }
+
+  *out = full_path;
+  return FileError::OK;
+}
+
+}  // namespace filesystem