Switch over to the google3 unix_file File*.
I also moved macros.h to base/macros.h to ease google3 porting, at
the expense of a larger than necessary change. (I learned my lesson,
though, and didn't make the equivalent base/logging.h change.)
I'm not sure whether we want to keep the unix_file MappedFile given
our existing MemMap, but it's easier to bring it over and then remove
it (and possibly revert the removal) than to bring it over later.
Change-Id: Id50a66faa5ab17b9bc936cc9043dbc26f791f0ca
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 7873645..cd0b27f 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -132,6 +132,11 @@
LIBART_COMMON_SRC_FILES := \
src/atomic.cc.arm \
+ src/base/unix_file/fd_file.cc \
+ src/base/unix_file/mapped_file.cc \
+ src/base/unix_file/null_file.cc \
+ src/base/unix_file/random_access_file_utils.cc \
+ src/base/unix_file/string_file.cc \
src/barrier.cc \
src/check_jni.cc \
src/class_linker.cc \
@@ -148,8 +153,6 @@
src/disassembler_mips.cc \
src/disassembler_x86.cc \
src/dlmalloc.cc \
- src/file.cc \
- src/file_linux.cc \
src/gc/card_table.cc \
src/gc/garbage_collector.cc \
src/gc/heap_bitmap.cc \
@@ -358,13 +361,17 @@
TEST_COMMON_SRC_FILES := \
src/barrier_test.cc \
+ src/base/unix_file/fd_file_test.cc \
+ src/base/unix_file/mapped_file_test.cc \
+ src/base/unix_file/null_file_test.cc \
+ src/base/unix_file/random_access_file_utils_test.cc \
+ src/base/unix_file/string_file_test.cc \
src/class_linker_test.cc \
src/compiler_test.cc \
src/dex_cache_test.cc \
src/dex_file_test.cc \
src/dex_instruction_visitor_test.cc \
src/exception_test.cc \
- src/file_test.cc \
src/gc/space_bitmap_test.cc \
src/gc/space_test.cc \
src/gtest_test.cc \
diff --git a/src/atomic.h b/src/atomic.h
index c6c0f7d..c69a9d1 100644
--- a/src/atomic.h
+++ b/src/atomic.h
@@ -19,9 +19,9 @@
#include <stdint.h>
+#include "base/macros.h"
#include "cutils/atomic.h"
#include "cutils/atomic-inline.h"
-#include "macros.h"
namespace art {
diff --git a/src/macros.h b/src/base/macros.h
similarity index 100%
rename from src/macros.h
rename to src/base/macros.h
diff --git a/src/base/unix_file/README b/src/base/unix_file/README
new file mode 100644
index 0000000..e9aec22
--- /dev/null
+++ b/src/base/unix_file/README
@@ -0,0 +1,15 @@
+A simple C++ wrapper for Unix file I/O.
+
+This is intended to be lightweight and easy to use, similar to Java's
+RandomAccessFile and related classes. The usual C++ idioms of RAII and "you
+don't pay for what you don't use" apply.
+
+In particular, the basic RandomAccessFile interface is kept small and simple so
+it's trivial to add new implementations.
+
+This code will not log, because it can't know whether that's appropriate in
+your application.
+
+This code will, in general, return -errno on failure. If an operation consisted
+of multiple sub-operations, it will return the errno corresponding to the most
+relevant operation.
diff --git a/src/base/unix_file/fd_file.cc b/src/base/unix_file/fd_file.cc
new file mode 100644
index 0000000..73130a3
--- /dev/null
+++ b/src/base/unix_file/fd_file.cc
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/fd_file.h"
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "logging.h"
+
+namespace unix_file {
+
+FdFile::FdFile() : fd_(-1), auto_close_(true) {
+}
+
+FdFile::FdFile(int fd) : fd_(fd), auto_close_(true) {
+}
+
+FdFile::FdFile(int fd, const std::string& path) : fd_(fd), file_path_(path), auto_close_(true) {
+}
+
+FdFile::~FdFile() {
+ if (auto_close_ && fd_ != -1) {
+ Close();
+ }
+}
+
+void FdFile::DisableAutoClose() {
+ auto_close_ = false;
+}
+
+bool FdFile::Open(const std::string& path, int flags) {
+ return Open(path, flags, 0640);
+}
+
+bool FdFile::Open(const std::string& path, int flags, mode_t mode) {
+ CHECK_EQ(fd_, -1) << path;
+ fd_ = TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode));
+ if (fd_ == -1) {
+ return false;
+ }
+ file_path_ = path;
+ return true;
+}
+
+int FdFile::Close() {
+ int result = TEMP_FAILURE_RETRY(close(fd_));
+ if (result == -1) {
+ return -errno;
+ } else {
+ fd_ = -1;
+ file_path_ = "";
+ return 0;
+ }
+}
+
+int FdFile::Flush() {
+ int rc = TEMP_FAILURE_RETRY(fdatasync(fd_));
+ return (rc == -1) ? -errno : rc;
+}
+
+int64_t FdFile::Read(char* buf, int64_t byte_count, int64_t offset) const {
+ int rc = TEMP_FAILURE_RETRY(pread64(fd_, buf, byte_count, offset));
+ return (rc == -1) ? -errno : rc;
+}
+
+int FdFile::SetLength(int64_t new_length) {
+ int rc = TEMP_FAILURE_RETRY(ftruncate64(fd_, new_length));
+ return (rc == -1) ? -errno : rc;
+}
+
+int64_t FdFile::GetLength() const {
+ struct stat s;
+ int rc = TEMP_FAILURE_RETRY(fstat(fd_, &s));
+ return (rc == -1) ? -errno : s.st_size;
+}
+
+int64_t FdFile::Write(const char* buf, int64_t byte_count, int64_t offset) {
+ int rc = TEMP_FAILURE_RETRY(pwrite64(fd_, buf, byte_count, offset));
+ return (rc == -1) ? -errno : rc;
+}
+
+int FdFile::Fd() const {
+ return fd_;
+}
+
+bool FdFile::IsOpened() const {
+ return fd_ >= 0;
+}
+
+std::string FdFile::GetPath() const {
+ return file_path_;
+}
+
+bool FdFile::ReadFully(void* buffer, int64_t byte_count) {
+ char* ptr = static_cast<char*>(buffer);
+ while (byte_count > 0) {
+ int bytes_read = TEMP_FAILURE_RETRY(read(fd_, ptr, byte_count));
+ if (bytes_read <= 0) {
+ return false;
+ }
+ byte_count -= bytes_read; // Reduce the number of remaining bytes.
+ ptr += bytes_read; // Move the buffer forward.
+ }
+ return true;
+}
+
+bool FdFile::WriteFully(const void* buffer, int64_t byte_count) {
+ const char* ptr = static_cast<const char*>(buffer);
+ while (byte_count > 0) {
+ int bytes_read = TEMP_FAILURE_RETRY(write(fd_, ptr, byte_count));
+ if (bytes_read < 0) {
+ return false;
+ }
+ byte_count -= bytes_read; // Reduce the number of remaining bytes.
+ ptr += bytes_read; // Move the buffer forward.
+ }
+ return true;
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/fd_file.h b/src/base/unix_file/fd_file.h
new file mode 100644
index 0000000..2b33961
--- /dev/null
+++ b/src/base/unix_file/fd_file.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_FD_FILE_H_
+#define BASE_UNIX_FILE_FD_FILE_H_
+
+#include <fcntl.h>
+#include <string>
+#include "base/unix_file/random_access_file.h"
+#include "base/macros.h"
+
+namespace unix_file {
+
+// A RandomAccessFile implementation backed by a file descriptor.
+//
+// Not thread safe.
+class FdFile : public RandomAccessFile {
+ public:
+ FdFile();
+ // Creates an FdFile using the given file descriptor. Takes ownership of the
+ // file descriptor. (Use DisableAutoClose to retain ownership.)
+ explicit FdFile(int fd);
+ explicit FdFile(int fd, const std::string& path);
+
+ // Destroys an FdFile, closing the file descriptor if Close hasn't already
+ // been called. (If you care about the return value of Close, call it
+ // yourself; this is meant to handle failure cases and read-only accesses.
+ // Note though that calling Close and checking its return value is still no
+ // guarantee that data actually made it to stable storage.)
+ virtual ~FdFile();
+
+ // Opens file 'file_path' using 'flags' and 'mode'.
+ bool Open(const std::string& file_path, int flags);
+ bool Open(const std::string& file_path, int flags, mode_t mode);
+
+ // RandomAccessFile API.
+ virtual int Close();
+ virtual int64_t Read(char* buf, int64_t byte_count, int64_t offset) const;
+ virtual int SetLength(int64_t new_length);
+ virtual int64_t GetLength() const;
+ virtual int64_t Write(const char* buf, int64_t byte_count, int64_t offset);
+ virtual int Flush();
+
+ // Bonus API.
+ int Fd() const;
+ bool IsOpened() const;
+ std::string GetPath() const;
+ void DisableAutoClose();
+ bool ReadFully(void* buffer, int64_t byte_count);
+ bool WriteFully(const void* buffer, int64_t byte_count);
+
+ private:
+ int fd_;
+ std::string file_path_;
+ bool auto_close_;
+
+ DISALLOW_COPY_AND_ASSIGN(FdFile);
+};
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_FD_FILE_H_
diff --git a/src/base/unix_file/fd_file_test.cc b/src/base/unix_file/fd_file_test.cc
new file mode 100644
index 0000000..d620666
--- /dev/null
+++ b/src/base/unix_file/fd_file_test.cc
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/fd_file.h"
+#include "base/unix_file/random_access_file_test.h"
+#include "gtest/gtest.h"
+
+namespace unix_file {
+
+class FdFileTest : public RandomAccessFileTest {
+ protected:
+ virtual RandomAccessFile* MakeTestFile() {
+ return new FdFile(fileno(tmpfile()));
+ }
+};
+
+TEST_F(FdFileTest, Read) {
+ TestRead();
+}
+
+TEST_F(FdFileTest, SetLength) {
+ TestSetLength();
+}
+
+TEST_F(FdFileTest, Write) {
+ TestWrite();
+}
+
+TEST_F(FdFileTest, UnopenedFile) {
+ FdFile file;
+ EXPECT_EQ(-1, file.Fd());
+ EXPECT_FALSE(file.IsOpened());
+ EXPECT_TRUE(file.GetPath().empty());
+}
+
+TEST_F(FdFileTest, OpenClose) {
+ std::string good_path(GetTmpPath("some-file.txt"));
+ FdFile file;
+ ASSERT_TRUE(file.Open(good_path, O_CREAT | O_WRONLY));
+ EXPECT_GE(file.Fd(), 0);
+ EXPECT_TRUE(file.IsOpened());
+ EXPECT_EQ(0, file.Close());
+ EXPECT_EQ(-1, file.Fd());
+ EXPECT_FALSE(file.IsOpened());
+ EXPECT_TRUE(file.Open(good_path, O_RDONLY));
+ EXPECT_GE(file.Fd(), 0);
+ EXPECT_TRUE(file.IsOpened());
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/mapped_file.cc b/src/base/unix_file/mapped_file.cc
new file mode 100644
index 0000000..84629b3
--- /dev/null
+++ b/src/base/unix_file/mapped_file.cc
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/mapped_file.h"
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <algorithm>
+#include <string>
+#include "logging.h"
+
+namespace unix_file {
+
+MappedFile::~MappedFile() {
+}
+
+int MappedFile::Close() {
+ if (IsMapped()) {
+ Unmap();
+ }
+ return FdFile::Close();
+}
+
+bool MappedFile::MapReadOnly() {
+ CHECK(IsOpened());
+ CHECK(!IsMapped());
+ struct stat st;
+ int result = TEMP_FAILURE_RETRY(fstat(Fd(), &st));
+ if (result == -1) {
+ PLOG(WARNING) << "Failed to stat file '" << GetPath() << "'";
+ return false;
+ }
+ file_size_ = st.st_size;
+ do {
+ mapped_file_ = mmap(NULL, file_size_, PROT_READ, MAP_PRIVATE, Fd(), 0);
+ } while (mapped_file_ == MAP_FAILED && errno == EINTR);
+ if (mapped_file_ == MAP_FAILED) {
+ PLOG(WARNING) << "Failed to mmap file '" << GetPath() << "' of size "
+ << file_size_ << " bytes to memory";
+ return false;
+ }
+ map_mode_ = kMapReadOnly;
+ return true;
+}
+
+bool MappedFile::MapReadWrite(int64_t file_size) {
+ CHECK(IsOpened());
+ CHECK(!IsMapped());
+ int result = TEMP_FAILURE_RETRY(ftruncate64(Fd(), file_size));
+ if (result == -1) {
+ PLOG(ERROR) << "Failed to truncate file '" << GetPath()
+ << "' to size " << file_size;
+ return false;
+ }
+ file_size_ = file_size;
+ do {
+ mapped_file_ =
+ mmap(NULL, file_size_, PROT_READ | PROT_WRITE, MAP_SHARED, Fd(), 0);
+ } while (mapped_file_ == MAP_FAILED && errno == EINTR);
+ if (mapped_file_ == MAP_FAILED) {
+ PLOG(WARNING) << "Failed to mmap file '" << GetPath() << "' of size "
+ << file_size_ << " bytes to memory";
+ return false;
+ }
+ map_mode_ = kMapReadWrite;
+ return true;
+}
+
+bool MappedFile::Unmap() {
+ CHECK(IsMapped());
+ int result = TEMP_FAILURE_RETRY(munmap(mapped_file_, file_size_));
+ if (result == -1) {
+ PLOG(WARNING) << "Failed unmap file '" << GetPath() << "' of size "
+ << file_size_;
+ return false;
+ } else {
+ mapped_file_ = NULL;
+ file_size_ = -1;
+ return true;
+ }
+}
+
+int64_t MappedFile::Read(char* buf, int64_t byte_count, int64_t offset) const {
+ if (IsMapped()) {
+ if (offset < 0) {
+ errno = EINVAL;
+ return -errno;
+ }
+ int64_t read_size = std::max(0LL, std::min(byte_count, file_size_ - offset));
+ if (read_size > 0) {
+ memcpy(buf, data() + offset, read_size);
+ }
+ return read_size;
+ } else {
+ return FdFile::Read(buf, byte_count, offset);
+ }
+}
+
+int MappedFile::SetLength(int64_t new_length) {
+ CHECK(!IsMapped());
+ return FdFile::SetLength(new_length);
+}
+
+int64_t MappedFile::GetLength() const {
+ if (IsMapped()) {
+ return file_size_;
+ } else {
+ return FdFile::GetLength();
+ }
+}
+
+int MappedFile::Flush() {
+ int rc = IsMapped() ? TEMP_FAILURE_RETRY(msync(mapped_file_, file_size_, 0)) : FdFile::Flush();
+ return rc == -1 ? -errno : 0;
+}
+
+int64_t MappedFile::Write(const char* buf, int64_t byte_count, int64_t offset) {
+ if (IsMapped()) {
+ CHECK_EQ(kMapReadWrite, map_mode_);
+ if (offset < 0) {
+ errno = EINVAL;
+ return -errno;
+ }
+ int64_t write_size = std::max(0LL, std::min(byte_count, file_size_ - offset));
+ if (write_size > 0) {
+ memcpy(data() + offset, buf, write_size);
+ }
+ return write_size;
+ } else {
+ return FdFile::Write(buf, byte_count, offset);
+ }
+}
+
+int64_t MappedFile::size() const {
+ return GetLength();
+}
+
+bool MappedFile::IsMapped() const {
+ return mapped_file_ != NULL && mapped_file_ != MAP_FAILED;
+}
+
+char* MappedFile::data() const {
+ CHECK(IsMapped());
+ return static_cast<char*>(mapped_file_);
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/mapped_file.h b/src/base/unix_file/mapped_file.h
new file mode 100644
index 0000000..161100b
--- /dev/null
+++ b/src/base/unix_file/mapped_file.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_MAPPED_FILE_H_
+#define BASE_UNIX_FILE_MAPPED_FILE_H_
+
+#include <fcntl.h>
+#include <string>
+#include "base/unix_file/fd_file.h"
+
+namespace unix_file {
+
+// Random access file which handles an mmap(2), munmap(2) pair in C++
+// RAII style. When a file is mmapped, the random access file
+// interface accesses the mmapped memory directly; otherwise, the
+// standard file I/O is used. Whenever a function fails, it returns
+// false and errno is set to the corresponding error code.
+class MappedFile : public FdFile {
+ public:
+ // File modes used in Open().
+ enum FileMode {
+ kReadOnlyMode = O_RDONLY | O_LARGEFILE,
+ kReadWriteMode = O_CREAT | O_RDWR | O_LARGEFILE,
+ };
+
+ MappedFile() : FdFile(), file_size_(-1), mapped_file_(NULL) {
+ }
+ // Creates a MappedFile using the given file descriptor. Takes ownership of
+ // the file descriptor.
+ explicit MappedFile(int fd) : FdFile(fd), file_size_(-1), mapped_file_(NULL) {
+ }
+
+ // Unmaps and closes the file if needed.
+ virtual ~MappedFile();
+
+ // Maps an opened file to memory in the read-only mode.
+ bool MapReadOnly();
+
+ // Maps an opened file to memory in the read-write mode. Before the
+ // file is mapped, it is truncated to 'file_size' bytes.
+ bool MapReadWrite(int64_t file_size);
+
+ // Unmaps a mapped file so that, e.g., SetLength() may be invoked.
+ bool Unmap();
+
+ // RandomAccessFile API.
+ // The functions below require that the file is open, but it doesn't
+ // have to be mapped.
+ virtual int Close();
+ virtual int64_t Read(char* buf, int64_t byte_count, int64_t offset) const;
+ // SetLength() requires that the file is not mmapped.
+ virtual int SetLength(int64_t new_length);
+ virtual int64_t GetLength() const;
+ virtual int Flush();
+ // Write() requires that, if the file is mmapped, it is mmapped in
+ // the read-write mode. Writes past the end of file are discarded.
+ virtual int64_t Write(const char* buf, int64_t byte_count, int64_t offset);
+
+ // A convenience method equivalent to GetLength().
+ int64_t size() const;
+
+ // Returns true if the file has been mmapped.
+ bool IsMapped() const;
+
+ // Returns a pointer to the start of the memory mapping once the
+ // file is successfully mapped; crashes otherwise.
+ char* data() const;
+
+ private:
+ enum MapMode {
+ kMapReadOnly = 1,
+ kMapReadWrite = 2,
+ };
+
+ mutable int64_t file_size_; // May be updated in GetLength().
+ void* mapped_file_;
+ MapMode map_mode_;
+
+ DISALLOW_COPY_AND_ASSIGN(MappedFile);
+};
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_MAPPED_FILE_H_
diff --git a/src/base/unix_file/mapped_file_test.cc b/src/base/unix_file/mapped_file_test.cc
new file mode 100644
index 0000000..f61ed3b
--- /dev/null
+++ b/src/base/unix_file/mapped_file_test.cc
@@ -0,0 +1,265 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/mapped_file.h"
+#include "base/unix_file/fd_file.h"
+#include "base/unix_file/random_access_file_test.h"
+#include "base/unix_file/random_access_file_utils.h"
+#include "base/unix_file/string_file.h"
+#include "gtest/gtest.h"
+#include "logging.h"
+
+namespace unix_file {
+
+class MappedFileTest : public RandomAccessFileTest {
+ protected:
+ MappedFileTest() : kContent("some content") {
+ }
+
+ void SetUp() {
+ art::CommonTest::SetEnvironmentVariables(android_data_);
+
+ good_path_ = GetTmpPath("some-file.txt");
+ int fd = TEMP_FAILURE_RETRY(open(good_path_.c_str(), O_CREAT|O_RDWR, 0666));
+ FdFile dst(fd);
+
+ StringFile src;
+ src.Assign(kContent);
+
+ ASSERT_TRUE(CopyFile(src, &dst));
+ }
+
+ virtual RandomAccessFile* MakeTestFile() {
+ TEMP_FAILURE_RETRY(truncate(good_path_.c_str(), 0));
+ MappedFile* f = new MappedFile;
+ CHECK(f->Open(good_path_, MappedFile::kReadWriteMode));
+ return f;
+ }
+
+ const std::string kContent;
+ std::string good_path_;
+};
+
+TEST_F(MappedFileTest, OkayToNotUse) {
+ MappedFile file;
+ EXPECT_EQ(-1, file.Fd());
+ EXPECT_FALSE(file.IsOpened());
+ EXPECT_FALSE(file.IsMapped());
+}
+
+TEST_F(MappedFileTest, OpenClose) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ EXPECT_GE(file.Fd(), 0);
+ EXPECT_TRUE(file.IsOpened());
+ EXPECT_EQ(kContent.size(), file.size());
+ EXPECT_EQ(0, file.Close());
+ EXPECT_EQ(-1, file.Fd());
+ EXPECT_FALSE(file.IsOpened());
+}
+
+TEST_F(MappedFileTest, OpenFdClose) {
+ FILE* f = tmpfile();
+ ASSERT_TRUE(f != NULL);
+ MappedFile file(fileno(f));
+ EXPECT_GE(file.Fd(), 0);
+ EXPECT_TRUE(file.IsOpened());
+ EXPECT_EQ(0, file.Close());
+}
+
+TEST_F(MappedFileTest, CanUseAfterMapReadOnly) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ EXPECT_FALSE(file.IsMapped());
+ EXPECT_TRUE(file.MapReadOnly());
+ EXPECT_TRUE(file.IsMapped());
+ EXPECT_EQ(kContent.size(), file.size());
+ ASSERT_TRUE(file.data());
+ EXPECT_EQ(0, memcmp(kContent.c_str(), file.data(), file.size()));
+ EXPECT_EQ(0, file.Flush());
+}
+
+TEST_F(MappedFileTest, CanUseAfterMapReadWrite) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadWriteMode));
+ EXPECT_FALSE(file.IsMapped());
+ EXPECT_TRUE(file.MapReadWrite(1));
+ EXPECT_TRUE(file.IsMapped());
+ EXPECT_EQ(1, file.size());
+ ASSERT_TRUE(file.data());
+ EXPECT_EQ(kContent[0], *file.data());
+ EXPECT_EQ(0, file.Flush());
+}
+
+TEST_F(MappedFileTest, CanWriteNewData) {
+ const std::string new_path(GetTmpPath("new-file.txt"));
+ ASSERT_EQ(-1, unlink(new_path.c_str()));
+ ASSERT_EQ(ENOENT, errno);
+
+ MappedFile file;
+ ASSERT_TRUE(file.Open(new_path, MappedFile::kReadWriteMode));
+ EXPECT_TRUE(file.MapReadWrite(kContent.size()));
+ EXPECT_TRUE(file.IsMapped());
+ EXPECT_EQ(kContent.size(), file.size());
+ ASSERT_TRUE(file.data());
+ memcpy(file.data(), kContent.c_str(), kContent.size());
+ EXPECT_EQ(0, file.Close());
+ EXPECT_FALSE(file.IsMapped());
+
+ FdFile new_file(TEMP_FAILURE_RETRY(open(new_path.c_str(), O_RDONLY)));
+ StringFile buffer;
+ ASSERT_TRUE(CopyFile(new_file, &buffer));
+ EXPECT_EQ(kContent, buffer.ToStringPiece());
+ EXPECT_EQ(0, unlink(new_path.c_str()));
+}
+
+TEST_F(MappedFileTest, FileMustExist) {
+ const std::string bad_path(GetTmpPath("does-not-exist.txt"));
+ MappedFile file;
+ EXPECT_FALSE(file.Open(bad_path, MappedFile::kReadOnlyMode));
+ EXPECT_EQ(-1, file.Fd());
+}
+
+TEST_F(MappedFileTest, FileMustBeWritable) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ EXPECT_FALSE(file.MapReadWrite(10));
+}
+
+TEST_F(MappedFileTest, RemappingAllowedUntilSuccess) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ EXPECT_FALSE(file.MapReadWrite(10));
+ EXPECT_FALSE(file.MapReadWrite(10));
+}
+
+TEST_F(MappedFileTest, ResizeMappedFile) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadWriteMode));
+ ASSERT_TRUE(file.MapReadWrite(10));
+ EXPECT_EQ(10, file.GetLength());
+ EXPECT_TRUE(file.Unmap());
+ EXPECT_TRUE(file.MapReadWrite(20));
+ EXPECT_EQ(20, file.GetLength());
+ EXPECT_EQ(0, file.Flush());
+ EXPECT_TRUE(file.Unmap());
+ EXPECT_EQ(0, file.Flush());
+ EXPECT_EQ(0, file.SetLength(5));
+ EXPECT_TRUE(file.MapReadOnly());
+ EXPECT_EQ(5, file.GetLength());
+}
+
+TEST_F(MappedFileTest, ReadNotMapped) {
+ TestRead();
+}
+
+TEST_F(MappedFileTest, SetLengthNotMapped) {
+ TestSetLength();
+}
+
+TEST_F(MappedFileTest, WriteNotMapped) {
+ TestWrite();
+}
+
+TEST_F(MappedFileTest, ReadMappedReadOnly) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ ASSERT_TRUE(file.MapReadOnly());
+ TestReadContent(kContent, &file);
+}
+
+TEST_F(MappedFileTest, ReadMappedReadWrite) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadWriteMode));
+ ASSERT_TRUE(file.MapReadWrite(kContent.size()));
+ TestReadContent(kContent, &file);
+}
+
+TEST_F(MappedFileTest, WriteMappedReadWrite) {
+ TEMP_FAILURE_RETRY(unlink(good_path_.c_str()));
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadWriteMode));
+ ASSERT_TRUE(file.MapReadWrite(kContent.size()));
+
+ // Can't write to a negative offset.
+ EXPECT_EQ(-EINVAL, file.Write(kContent.c_str(), 0, -123));
+
+ // A zero-length write is a no-op.
+ EXPECT_EQ(0, file.Write(kContent.c_str(), 0, 0));
+ // But the file size is as given when mapped.
+ EXPECT_EQ(kContent.size(), file.GetLength());
+
+ // Data written past the end are discarded.
+ EXPECT_EQ(kContent.size() - 1,
+ file.Write(kContent.c_str(), kContent.size(), 1));
+ EXPECT_EQ(0, memcmp(kContent.c_str(), file.data() + 1, kContent.size() - 1));
+
+ // Data can be overwritten.
+ EXPECT_EQ(kContent.size(), file.Write(kContent.c_str(), kContent.size(), 0));
+ EXPECT_EQ(0, memcmp(kContent.c_str(), file.data(), kContent.size()));
+}
+
+#if 0 // death tests don't work on android yet
+
+class MappedFileDeathTest : public MappedFileTest {};
+
+TEST_F(MappedFileDeathTest, MustMapBeforeUse) {
+ MappedFile file;
+ EXPECT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ EXPECT_DEATH(file.data(), "mapped_");
+}
+
+TEST_F(MappedFileDeathTest, RemappingNotAllowedReadOnly) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ ASSERT_TRUE(file.MapReadOnly());
+ EXPECT_DEATH(file.MapReadOnly(), "mapped_");
+}
+
+TEST_F(MappedFileDeathTest, RemappingNotAllowedReadWrite) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadWriteMode));
+ ASSERT_TRUE(file.MapReadWrite(10));
+ EXPECT_DEATH(file.MapReadWrite(10), "mapped_");
+}
+
+TEST_F(MappedFileDeathTest, SetLengthMappedReadWrite) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadWriteMode));
+ ASSERT_TRUE(file.MapReadWrite(10));
+ EXPECT_EQ(10, file.GetLength());
+ EXPECT_DEATH(file.SetLength(0), ".*");
+}
+
+TEST_F(MappedFileDeathTest, SetLengthMappedReadOnly) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ ASSERT_TRUE(file.MapReadOnly());
+ EXPECT_EQ(kContent.size(), file.GetLength());
+ EXPECT_DEATH(file.SetLength(0), ".*");
+}
+
+TEST_F(MappedFileDeathTest, WriteMappedReadOnly) {
+ MappedFile file;
+ ASSERT_TRUE(file.Open(good_path_, MappedFile::kReadOnlyMode));
+ ASSERT_TRUE(file.MapReadOnly());
+ char buf[10];
+ EXPECT_DEATH(file.Write(buf, 0, 0), ".*");
+}
+
+#endif
+
+} // namespace unix_file
diff --git a/src/base/unix_file/null_file.cc b/src/base/unix_file/null_file.cc
new file mode 100644
index 0000000..050decb
--- /dev/null
+++ b/src/base/unix_file/null_file.cc
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/null_file.h"
+#include <errno.h>
+
+namespace unix_file {
+
+NullFile::NullFile() {
+}
+
+NullFile::~NullFile() {
+}
+
+int NullFile::Close() {
+ return 0;
+}
+
+int NullFile::Flush() {
+ return 0;
+}
+
+int64_t NullFile::Read(char* buf, int64_t byte_count, int64_t offset) const {
+ if (offset < 0) {
+ return -EINVAL;
+ }
+ return 0;
+}
+
+int NullFile::SetLength(int64_t new_length) {
+ if (new_length < 0) {
+ return -EINVAL;
+ }
+ return 0;
+}
+
+int64_t NullFile::GetLength() const {
+ return 0;
+}
+
+int64_t NullFile::Write(const char* buf, int64_t byte_count, int64_t offset) {
+ if (offset < 0) {
+ return -EINVAL;
+ }
+ return byte_count;
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/null_file.h b/src/base/unix_file/null_file.h
new file mode 100644
index 0000000..e716603
--- /dev/null
+++ b/src/base/unix_file/null_file.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_NULL_FILE_H_
+#define BASE_UNIX_FILE_NULL_FILE_H_
+
+#include "base/unix_file/random_access_file.h"
+#include "base/macros.h"
+
+namespace unix_file {
+
+// A RandomAccessFile implementation equivalent to /dev/null. Writes are
+// discarded, and there's no data to be read. Callers could use FdFile in
+// conjunction with /dev/null, but that's not portable and costs a file
+// descriptor. NullFile is "free".
+//
+// Thread safe.
+class NullFile : public RandomAccessFile {
+ public:
+ NullFile();
+ virtual ~NullFile();
+
+ // RandomAccessFile API.
+ virtual int Close();
+ virtual int Flush();
+ virtual int64_t Read(char* buf, int64_t byte_count, int64_t offset) const;
+ virtual int SetLength(int64_t new_length);
+ virtual int64_t GetLength() const;
+ virtual int64_t Write(const char* buf, int64_t byte_count, int64_t offset);
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(NullFile);
+};
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_NULL_FILE_H_
diff --git a/src/base/unix_file/null_file_test.cc b/src/base/unix_file/null_file_test.cc
new file mode 100644
index 0000000..0f20acd
--- /dev/null
+++ b/src/base/unix_file/null_file_test.cc
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/null_file.h"
+
+#include <errno.h>
+
+#include "gtest/gtest.h"
+
+namespace unix_file {
+
+class NullFileTest : public testing::Test { };
+
+TEST_F(NullFileTest, Read) {
+ NullFile f;
+ char buf[256];
+ // You can't read a negative number of bytes...
+ ASSERT_EQ(-EINVAL, f.Read(buf, 0, -1));
+ // ...but everything else is fine (though you'll get no data).
+ ASSERT_EQ(0, f.Read(buf, 128, 0));
+ ASSERT_EQ(0, f.Read(buf, 128, 128));
+}
+
+TEST_F(NullFileTest, SetLength) {
+ NullFile f;
+ // You can't set a negative length...
+ ASSERT_EQ(-EINVAL, f.SetLength(-1));
+ // ...but everything else is fine.
+ ASSERT_EQ(0, f.SetLength(0));
+ ASSERT_EQ(0, f.SetLength(128));
+}
+
+TEST_F(NullFileTest, GetLength) {
+ const std::string content("hello");
+ NullFile f;
+ // The length is always 0.
+ ASSERT_EQ(0, f.GetLength());
+ ASSERT_EQ(content.size(), f.Write(content.data(), content.size(), 0));
+ ASSERT_EQ(0, f.GetLength());
+}
+
+TEST_F(NullFileTest, Write) {
+ const std::string content("hello");
+ NullFile f;
+ // You can't write at a negative offset...
+ ASSERT_EQ(-EINVAL, f.Write(content.data(), content.size(), -128));
+ // But you can write anywhere else...
+ ASSERT_EQ(content.size(), f.Write(content.data(), content.size(), 0));
+ ASSERT_EQ(content.size(), f.Write(content.data(), content.size(), 128));
+ // ...though the file will remain empty.
+ ASSERT_EQ(0, f.GetLength());
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/random_access_file.h b/src/base/unix_file/random_access_file.h
new file mode 100644
index 0000000..22da37f
--- /dev/null
+++ b/src/base/unix_file/random_access_file.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_RANDOM_ACCESS_FILE_H_
+#define BASE_UNIX_FILE_RANDOM_ACCESS_FILE_H_
+
+#include <stdint.h>
+
+namespace unix_file {
+
+// A file interface supporting random-access reading and writing of content,
+// along with the ability to set the length of a file (smaller or greater than
+// its current extent).
+//
+// This interface does not support a stream position (i.e. every read or write
+// must specify an offset). This interface does not imply any buffering policy.
+//
+// All operations return >= 0 on success or -errno on failure.
+//
+// Implementations never return EINTR; callers are spared the need to manually
+// retry interrupted operations.
+//
+// Any concurrent access to files should be externally synchronized.
+class RandomAccessFile {
+ public:
+ virtual ~RandomAccessFile() { }
+
+ virtual int Close() = 0;
+
+ // Reads 'byte_count' bytes into 'buf' starting at offset 'offset' in the
+ // file. Returns the number of bytes actually read.
+ virtual int64_t Read(char* buf, int64_t byte_count, int64_t offset) const = 0;
+
+ // Sets the length of the file to 'new_length'. If this is smaller than the
+ // file's current extent, data is discarded. If this is greater than the
+ // file's current extent, it is as if a write of the relevant number of zero
+ // bytes occurred. Returns 0 on success.
+ virtual int SetLength(int64_t new_length) = 0;
+
+ // Returns the current size of this file.
+ virtual int64_t GetLength() const = 0;
+
+ // Writes 'byte_count' bytes from 'buf' starting at offset 'offset' in the
+ // file. Zero-byte writes are acceptable, and writes past the end are as if
+ // a write of the relevant number of zero bytes also occurred. Returns the
+ // number of bytes actually written.
+ virtual int64_t Write(const char* buf, int64_t byte_count, int64_t offset) = 0;
+
+ // Flushes file data.
+ virtual int Flush() = 0;
+};
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_RANDOM_ACCESS_FILE_H_
diff --git a/src/base/unix_file/random_access_file_test.h b/src/base/unix_file/random_access_file_test.h
new file mode 100644
index 0000000..3baaeae
--- /dev/null
+++ b/src/base/unix_file/random_access_file_test.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_RANDOM_ACCESS_FILE_TEST_H_
+#define BASE_UNIX_FILE_RANDOM_ACCESS_FILE_TEST_H_
+
+#include <errno.h>
+
+#include <string>
+
+#include "common_test.h"
+#include "gtest/gtest.h"
+#include "UniquePtr.h"
+
+namespace unix_file {
+
+class RandomAccessFileTest : public testing::Test {
+ protected:
+ virtual ~RandomAccessFileTest() {
+ }
+
+ // Override this to return an instance of the subclass under test that's
+ // backed by a temporary file.
+ virtual RandomAccessFile* MakeTestFile() = 0;
+
+ virtual void SetUp() {
+ art::CommonTest::SetEnvironmentVariables(android_data_);
+ }
+
+ std::string GetTmpPath(const std::string& name) {
+ std::string path;
+ path = android_data_;
+ path += "/";
+ path += name;
+ return path;
+ }
+
+ // TODO(enh): ReadString (and WriteString) might be generally useful.
+ static bool ReadString(RandomAccessFile* f, std::string* s) {
+ s->clear();
+ char buf[256];
+ int64_t n = 0;
+ int64_t offset = 0;
+ while ((n = f->Read(buf, sizeof(buf), offset)) > 0) {
+ s->append(buf, n);
+ offset += n;
+ }
+ return n != -1;
+ }
+
+ void TestRead() {
+ char buf[256];
+ UniquePtr<RandomAccessFile> file(MakeTestFile());
+
+ // Reading from the start of an empty file gets you zero bytes, however many
+ // you ask for.
+ ASSERT_EQ(0, file->Read(buf, 0, 0));
+ ASSERT_EQ(0, file->Read(buf, 123, 0));
+
+ const std::string content("hello");
+ ASSERT_EQ(content.size(), file->Write(content.data(), content.size(), 0));
+
+ TestReadContent(content, file.get());
+ }
+
+ void TestReadContent(const std::string& content, RandomAccessFile* file) {
+ const int buf_size = content.size() + 10;
+ UniquePtr<char> buf(new char[buf_size]);
+ // Can't read from a negative offset.
+ ASSERT_EQ(-EINVAL, file->Read(buf.get(), 0, -123));
+
+ // Reading too much gets us just what's in the file.
+ ASSERT_EQ(content.size(), file->Read(buf.get(), buf_size, 0));
+ ASSERT_EQ(std::string(buf.get(), content.size()), content);
+
+ // We only get as much as we ask for.
+ const size_t short_request = 2;
+ ASSERT_LT(short_request, content.size());
+ ASSERT_EQ(short_request, file->Read(buf.get(), short_request, 0));
+ ASSERT_EQ(std::string(buf.get(), short_request),
+ content.substr(0, short_request));
+
+ // We don't have to start at the beginning.
+ const int non_zero_offset = 2;
+ ASSERT_GT(non_zero_offset, 0);
+ ASSERT_EQ(short_request,
+ file->Read(buf.get(), short_request, non_zero_offset));
+ ASSERT_EQ(std::string(buf.get(), short_request),
+ content.substr(non_zero_offset, short_request));
+
+ // Reading past the end gets us nothing.
+ ASSERT_EQ(0, file->Read(buf.get(), buf_size, file->GetLength()));
+ ASSERT_EQ(0, file->Read(buf.get(), buf_size, file->GetLength() + 1));
+ }
+
+ void TestSetLength() {
+ const std::string content("hello");
+ UniquePtr<RandomAccessFile> file(MakeTestFile());
+ ASSERT_EQ(content.size(), file->Write(content.data(), content.size(), 0));
+ ASSERT_EQ(content.size(), file->GetLength());
+
+ // Can't give a file a negative length.
+ ASSERT_EQ(-EINVAL, file->SetLength(-123));
+
+ // Can truncate the file.
+ int64_t new_length = 2;
+ ASSERT_EQ(0, file->SetLength(new_length));
+ ASSERT_EQ(new_length, file->GetLength());
+ std::string new_content;
+ ASSERT_TRUE(ReadString(file.get(), &new_content));
+ ASSERT_EQ(content.substr(0, 2), new_content);
+
+ // Expanding the file appends zero bytes.
+ new_length = file->GetLength() + 1;
+ ASSERT_EQ(0, file->SetLength(new_length));
+ ASSERT_EQ(new_length, file->GetLength());
+ ASSERT_TRUE(ReadString(file.get(), &new_content));
+ ASSERT_EQ('\0', new_content[new_length - 1]);
+ }
+
+ void TestWrite() {
+ const std::string content("hello");
+ UniquePtr<RandomAccessFile> file(MakeTestFile());
+
+ // Can't write to a negative offset.
+ ASSERT_EQ(-EINVAL, file->Write(content.data(), 0, -123));
+
+ // Writing zero bytes of data is a no-op.
+ ASSERT_EQ(0, file->Write(content.data(), 0, 0));
+ ASSERT_EQ(0, file->GetLength());
+
+ // We can write data.
+ ASSERT_EQ(content.size(), file->Write(content.data(), content.size(), 0));
+ ASSERT_EQ(content.size(), file->GetLength());
+ std::string new_content;
+ ASSERT_TRUE(ReadString(file.get(), &new_content));
+ ASSERT_EQ(new_content, content);
+
+ // We can read it back.
+ char buf[256];
+ ASSERT_EQ(content.size(), file->Read(buf, sizeof(buf), 0));
+ ASSERT_EQ(std::string(buf, content.size()), content);
+
+ // We can append data past the end.
+ ASSERT_EQ(content.size(),
+ file->Write(content.data(), content.size(), file->GetLength() + 1));
+ int64_t new_length = 2*content.size() + 1;
+ ASSERT_EQ(file->GetLength(), new_length);
+ ASSERT_TRUE(ReadString(file.get(), &new_content));
+ ASSERT_EQ(std::string("hello\0hello", new_length), new_content);
+ }
+
+ protected:
+ std::string android_data_;
+};
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_RANDOM_ACCESS_FILE_TEST_H_
diff --git a/src/base/unix_file/random_access_file_utils.cc b/src/base/unix_file/random_access_file_utils.cc
new file mode 100644
index 0000000..df3b308
--- /dev/null
+++ b/src/base/unix_file/random_access_file_utils.cc
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vector>
+#include "base/unix_file/random_access_file_utils.h"
+#include "base/unix_file/random_access_file.h"
+
+namespace unix_file {
+
+bool CopyFile(const RandomAccessFile& src, RandomAccessFile* dst) {
+ // We don't call src->GetLength because some files (those in /proc, say)
+ // don't know how long they are. We just read until there's nothing left.
+ std::vector<char> buf(4096);
+ int64_t offset = 0;
+ int64_t n;
+ while ((n = src.Read(&buf[0], buf.size(), offset)) > 0) {
+ if (dst->Write(&buf[0], n, offset) != n) {
+ return false;
+ }
+ offset += n;
+ }
+ return n >= 0;
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/random_access_file_utils.h b/src/base/unix_file/random_access_file_utils.h
new file mode 100644
index 0000000..0535ead
--- /dev/null
+++ b/src/base/unix_file/random_access_file_utils.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_RANDOM_ACCESS_FILE_UTILS_H_
+#define BASE_UNIX_FILE_RANDOM_ACCESS_FILE_UTILS_H_
+
+namespace unix_file {
+
+class RandomAccessFile;
+
+// Copies from 'src' to 'dst'. Reads all the data from 'src', and writes it
+// to 'dst'. Not thread-safe. Neither file will be closed.
+bool CopyFile(const RandomAccessFile& src, RandomAccessFile* dst);
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_RANDOM_ACCESS_FILE_UTILS_H_
diff --git a/src/base/unix_file/random_access_file_utils_test.cc b/src/base/unix_file/random_access_file_utils_test.cc
new file mode 100644
index 0000000..6317922
--- /dev/null
+++ b/src/base/unix_file/random_access_file_utils_test.cc
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/random_access_file_utils.h"
+#include "base/unix_file/fd_file.h"
+#include "base/unix_file/string_file.h"
+#include "gtest/gtest.h"
+
+namespace unix_file {
+
+class RandomAccessFileUtilsTest : public testing::Test { };
+
+TEST_F(RandomAccessFileUtilsTest, CopyFile) {
+ StringFile src;
+ StringFile dst;
+
+ const std::string content("hello");
+ src.Assign(content);
+ ASSERT_EQ(src.ToStringPiece(), content);
+ ASSERT_EQ(dst.ToStringPiece(), "");
+
+ ASSERT_TRUE(CopyFile(src, &dst));
+ ASSERT_EQ(src.ToStringPiece(), dst.ToStringPiece());
+}
+
+TEST_F(RandomAccessFileUtilsTest, BadSrc) {
+ FdFile src(-1);
+ StringFile dst;
+ ASSERT_FALSE(CopyFile(src, &dst));
+}
+
+TEST_F(RandomAccessFileUtilsTest, BadDst) {
+ StringFile src;
+ FdFile dst(-1);
+
+ // We need some source content to trigger a write.
+ // Copying an empty file is a no-op.
+ src.Assign("hello");
+
+ ASSERT_FALSE(CopyFile(src, &dst));
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/string_file.cc b/src/base/unix_file/string_file.cc
new file mode 100644
index 0000000..5d47b17
--- /dev/null
+++ b/src/base/unix_file/string_file.cc
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/string_file.h"
+#include <errno.h>
+#include <algorithm>
+#include "logging.h"
+
+namespace unix_file {
+
+StringFile::StringFile() {
+}
+
+StringFile::~StringFile() {
+}
+
+int StringFile::Close() {
+ return 0;
+}
+
+int StringFile::Flush() {
+ return 0;
+}
+
+int64_t StringFile::Read(char *buf, int64_t byte_count, int64_t offset) const {
+ CHECK(buf);
+ CHECK_GE(byte_count, 0);
+
+ if (offset < 0) {
+ return -EINVAL;
+ }
+
+ const int64_t available_bytes = std::min(byte_count, GetLength() - offset);
+ if (available_bytes < 0) {
+ return 0; // Not an error, but nothing for us to do, either.
+ }
+ memcpy(buf, data_.data() + offset, available_bytes);
+ return available_bytes;
+}
+
+int StringFile::SetLength(int64_t new_length) {
+ if (new_length < 0) {
+ return -EINVAL;
+ }
+ data_.resize(new_length);
+ return 0;
+}
+
+int64_t StringFile::GetLength() const {
+ return data_.size();
+}
+
+int64_t StringFile::Write(const char *buf, int64_t byte_count, int64_t offset) {
+ CHECK(buf);
+ CHECK_GE(byte_count, 0);
+
+ if (offset < 0) {
+ return -EINVAL;
+ }
+
+ if (byte_count == 0) {
+ return 0;
+ }
+
+ // FUSE seems happy to allow writes past the end. (I'd guess it doesn't
+ // synthesize a write of zero bytes so that we're free to implement sparse
+ // files.) GNU as(1) seems to require such writes. Those files are small.
+ const int64_t bytes_past_end = offset - GetLength();
+ if (bytes_past_end > 0) {
+ data_.append(bytes_past_end, '\0');
+ }
+
+ data_.replace(offset, byte_count, buf, byte_count);
+ return byte_count;
+}
+
+void StringFile::Assign(const art::StringPiece &new_data) {
+ data_.assign(new_data.data(), new_data.size());
+}
+
+const art::StringPiece StringFile::ToStringPiece() const {
+ return data_;
+}
+
+} // namespace unix_file
diff --git a/src/base/unix_file/string_file.h b/src/base/unix_file/string_file.h
new file mode 100644
index 0000000..4277dc2
--- /dev/null
+++ b/src/base/unix_file/string_file.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_UNIX_FILE_STRING_FILE_H_
+#define BASE_UNIX_FILE_STRING_FILE_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "base/macros.h"
+#include "base/unix_file/random_access_file.h"
+#include "stringpiece.h"
+
+namespace unix_file {
+
+// A RandomAccessFile implementation backed by a std::string. (That is, all data is
+// kept in memory.)
+//
+// Not thread safe.
+class StringFile : public RandomAccessFile {
+ public:
+ StringFile();
+ virtual ~StringFile();
+
+ // RandomAccessFile API.
+ virtual int Close();
+ virtual int Flush();
+ virtual int64_t Read(char* buf, int64_t byte_count, int64_t offset) const;
+ virtual int SetLength(int64_t new_length);
+ virtual int64_t GetLength() const;
+ virtual int64_t Write(const char* buf, int64_t byte_count, int64_t offset);
+
+ // Bonus API.
+ void Assign(const art::StringPiece& new_data);
+ const art::StringPiece ToStringPiece() const;
+
+ private:
+ std::string data_;
+
+ DISALLOW_COPY_AND_ASSIGN(StringFile);
+};
+
+} // namespace unix_file
+
+#endif // BASE_UNIX_FILE_STRING_FILE_H_
diff --git a/src/base/unix_file/string_file_test.cc b/src/base/unix_file/string_file_test.cc
new file mode 100644
index 0000000..8821461
--- /dev/null
+++ b/src/base/unix_file/string_file_test.cc
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/unix_file/string_file.h"
+#include "base/unix_file/random_access_file_test.h"
+#include "gtest/gtest.h"
+
+namespace unix_file {
+
+class StringFileTest : public RandomAccessFileTest {
+ protected:
+ virtual RandomAccessFile* MakeTestFile() {
+ return new StringFile;
+ }
+};
+
+TEST_F(StringFileTest, Read) {
+ TestRead();
+}
+
+TEST_F(StringFileTest, SetLength) {
+ TestSetLength();
+}
+
+TEST_F(StringFileTest, Write) {
+ TestWrite();
+}
+
+} // namespace unix_file
diff --git a/src/casts.h b/src/casts.h
index f5580dd..f996dcd 100644
--- a/src/casts.h
+++ b/src/casts.h
@@ -19,7 +19,7 @@
#include <assert.h>
#include <string.h>
-#include "macros.h"
+#include "base/macros.h"
namespace art {
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 9a354e1..97b25ba 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -27,6 +27,7 @@
#include <utility>
#include <vector>
+#include "base/unix_file/fd_file.h"
#include "casts.h"
#include "class_loader.h"
#include "debugger.h"
diff --git a/src/class_linker.h b/src/class_linker.h
index 14c719e..e85a7f9 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -21,11 +21,11 @@
#include <utility>
#include <vector>
+#include "base/macros.h"
#include "dex_cache.h"
#include "dex_file.h"
#include "gtest/gtest.h"
#include "heap.h"
-#include "macros.h"
#include "mutex.h"
#include "oat_file.h"
#include "object.h"
diff --git a/src/common_test.h b/src/common_test.h
index f564bbd..9dbdbfc 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -20,15 +20,15 @@
#include <sys/stat.h>
#include <sys/types.h>
+#include "base/macros.h"
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "class_loader.h"
#include "compiler.h"
#include "dex_file.h"
-#include "file.h"
#include "gtest/gtest.h"
#include "heap.h"
#include "instruction_set.h"
-#include "macros.h"
#include "oat_file.h"
#include "object_utils.h"
#include "os.h"
@@ -143,16 +143,14 @@
ScratchFile() {
filename_ = getenv("ANDROID_DATA");
filename_ += "/TmpFile-XXXXXX";
- fd_ = mkstemp(&filename_[0]);
- CHECK_NE(-1, fd_);
- file_.reset(OS::FileFromFd(GetFilename().c_str(), fd_));
+ int fd = mkstemp(&filename_[0]);
+ CHECK_NE(-1, fd);
+ file_.reset(new File(fd, GetFilename()));
}
~ScratchFile() {
int unlink_result = unlink(filename_.c_str());
CHECK_EQ(0, unlink_result);
- int close_result = close(fd_);
- CHECK_EQ(0, close_result);
}
const std::string& GetFilename() const {
@@ -164,12 +162,11 @@
}
int GetFd() const {
- return fd_;
+ return file_->Fd();
}
private:
std::string filename_;
- int fd_;
UniquePtr<File> file_;
};
@@ -289,11 +286,8 @@
#endif
}
- protected:
- virtual void SetUp() {
- is_host_ = getenv("ANDROID_BUILD_TOP") != NULL;
-
- if (is_host_) {
+ static void SetEnvironmentVariables(std::string& android_data) {
+ if (IsHost()) {
// $ANDROID_ROOT is set on the device, but not on the host.
// We need to set this so that icu4c can find its locale data.
std::string root;
@@ -310,11 +304,20 @@
}
// On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of art-cache
- android_data_ = (is_host_ ? "/tmp/art-data-XXXXXX" : "/data/art-cache/art-data-XXXXXX");
- if (mkdtemp(&android_data_[0]) == NULL) {
- PLOG(FATAL) << "mkdtemp(\"" << &android_data_[0] << "\") failed";
+ android_data = (IsHost() ? "/tmp/art-data-XXXXXX" : "/data/art-cache/art-data-XXXXXX");
+ if (mkdtemp(&android_data[0]) == NULL) {
+ PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed";
}
- setenv("ANDROID_DATA", android_data_.c_str(), 1);
+ setenv("ANDROID_DATA", android_data.c_str(), 1);
+ }
+
+ protected:
+ static bool IsHost() {
+ return (getenv("ANDROID_BUILD_TOP") != NULL);
+ }
+
+ virtual void SetUp() {
+ SetEnvironmentVariables(android_data_);
art_cache_.append(android_data_.c_str());
art_cache_.append("/art-cache");
int mkdir_result = mkdir(art_cache_.c_str(), 0700);
@@ -434,7 +437,7 @@
}
std::string GetLibCoreDexFileName() {
- if (is_host_) {
+ if (IsHost()) {
const char* host_dir = getenv("ANDROID_HOST_OUT");
CHECK(host_dir != NULL);
return StringPrintf("%s/framework/core-hostdex.jar", host_dir);
@@ -445,7 +448,7 @@
const DexFile* OpenTestDexFile(const char* name) {
CHECK(name != NULL);
std::string filename;
- if (is_host_) {
+ if (IsHost()) {
filename += getenv("ANDROID_HOST_OUT");
filename += "/framework/";
} else {
@@ -524,7 +527,6 @@
CompileMethod(method);
}
- bool is_host_;
std::string android_data_;
std::string art_cache_;
const DexFile* java_lang_dex_file_; // owned by runtime_
diff --git a/src/compiler_llvm/compilation_unit.cc b/src/compiler_llvm/compilation_unit.cc
index 3524cdd..b482d00 100644
--- a/src/compiler_llvm/compilation_unit.cc
+++ b/src/compiler_llvm/compilation_unit.cc
@@ -18,7 +18,6 @@
#include "compiled_method.h"
#include "compiler_llvm.h"
-#include "file.h"
#include "instruction_set.h"
#include "ir_builder.h"
#include "logging.h"
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index 0867e56..9aa9791 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -17,10 +17,10 @@
#ifndef ART_SRC_COMPILER_LLVM_COMPILER_LLVM_H_
#define ART_SRC_COMPILER_LLVM_COMPILER_LLVM_H_
+#include "base/macros.h"
#include "compiler.h"
#include "dex_file.h"
#include "instruction_set.h"
-#include "macros.h"
#include "object.h"
#include "procedure_linkage_table.h"
diff --git a/src/constants_mips.h b/src/constants_mips.h
index 08661e9..a03a0c5 100644
--- a/src/constants_mips.h
+++ b/src/constants_mips.h
@@ -18,9 +18,9 @@
#define ART_SRC_CONSTANTS_MIPS_H_
#include <iosfwd>
+#include "base/macros.h"
#include "globals.h"
#include "logging.h"
-#include "macros.h"
namespace art {
namespace mips {
diff --git a/src/constants_x86.h b/src/constants_x86.h
index 7181f99..e1ddd9a 100644
--- a/src/constants_x86.h
+++ b/src/constants_x86.h
@@ -18,9 +18,9 @@
#define ART_SRC_CONSTANTS_X86_H_
#include <iosfwd>
+#include "base/macros.h"
#include "globals.h"
#include "logging.h"
-#include "macros.h"
namespace art {
namespace x86 {
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 5739057..550f857 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -23,10 +23,10 @@
#include <string>
#include <vector>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "class_loader.h"
#include "compiler.h"
-#include "file.h"
#include "image_writer.h"
#include "leb128.h"
#include "oat_writer.h"
@@ -274,7 +274,7 @@
image_file_location_oat_begin,
image_file_location,
*compiler.get())) {
- LOG(ERROR) << "Failed to create oat file " << oat_file->name();
+ LOG(ERROR) << "Failed to create oat file " << oat_file->GetPath();
return NULL;
}
return compiler.release();
@@ -797,7 +797,8 @@
oat_location = oat_filename;
}
} else {
- oat_file.reset(OS::FileFromFd(oat_location.c_str(), oat_fd));
+ oat_file.reset(new File(oat_fd, oat_location));
+ oat_file->DisableAutoClose();
}
if (oat_file.get() == NULL) {
PLOG(ERROR) << "Failed to create oat file: " << oat_location;
diff --git a/src/dex_cache.h b/src/dex_cache.h
index 8d88dc6..ee44856 100644
--- a/src/dex_cache.h
+++ b/src/dex_cache.h
@@ -17,9 +17,9 @@
#ifndef ART_SRC_DEX_CACHE_H_
#define ART_SRC_DEX_CACHE_H_
+#include "base/macros.h"
#include "dex_file.h"
#include "globals.h"
-#include "macros.h"
#include "object.h"
namespace art {
diff --git a/src/dex_instruction.h b/src/dex_instruction.h
index 48dbb0c..658e756 100644
--- a/src/dex_instruction.h
+++ b/src/dex_instruction.h
@@ -17,9 +17,9 @@
#ifndef ART_SRC_DEX_INSTRUCTION_H_
#define ART_SRC_DEX_INSTRUCTION_H_
+#include "base/macros.h"
#include "globals.h"
#include "logging.h"
-#include "macros.h"
namespace art {
diff --git a/src/dex_instruction_visitor.h b/src/dex_instruction_visitor.h
index d625b64..ff4620f 100644
--- a/src/dex_instruction_visitor.h
+++ b/src/dex_instruction_visitor.h
@@ -17,8 +17,8 @@
#ifndef ART_SRC_DEX_INSTRUCTION_VISITOR_H_
#define ART_SRC_DEX_INSTRUCTION_VISITOR_H_
+#include "base/macros.h"
#include "dex_instruction.h"
-#include "macros.h"
namespace art {
diff --git a/src/disassembler.h b/src/disassembler.h
index afff7f1..1f50bfc 100644
--- a/src/disassembler.h
+++ b/src/disassembler.h
@@ -21,8 +21,8 @@
#include <iosfwd>
+#include "base/macros.h"
#include "instruction_set.h"
-#include "macros.h"
namespace art {
diff --git a/src/file.cc b/src/file.cc
deleted file mode 100644
index 310876b..0000000
--- a/src/file.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "file.h"
-
-namespace art {
-
-bool File::ReadFully(void* buffer, int64_t num_bytes) {
- int64_t remaining = num_bytes;
- char* current_buffer = reinterpret_cast<char*>(buffer);
- while (remaining > 0) {
- int bytes_read = Read(current_buffer, remaining);
- if (bytes_read <= 0) {
- return false;
- }
- remaining -= bytes_read; // Reduce the number of remaining bytes.
- current_buffer += bytes_read; // Move the buffer forward.
- }
- return true;
-}
-
-
-bool File::WriteFully(const void* buffer, int64_t num_bytes) {
- int64_t remaining = num_bytes;
- const char* current_buffer = reinterpret_cast<const char*>(buffer);
- while (remaining > 0) {
- int bytes_read = Write(current_buffer, remaining);
- if (bytes_read < 0) {
- return false;
- }
- remaining -= bytes_read; // Reduce the number of remaining bytes.
- current_buffer += bytes_read; // Move the buffer forward.
- }
- return true;
-}
-
-} // namespace art
diff --git a/src/file.h b/src/file.h
deleted file mode 100644
index 7e3d72b..0000000
--- a/src/file.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ART_SRC_FILE_H_
-#define ART_SRC_FILE_H_
-
-#include <stdint.h>
-#include <sys/types.h>
-
-namespace art {
-
-class File {
- public:
- virtual ~File() { }
-
- virtual int64_t Read(void* buffer, int64_t num_bytes) = 0;
- virtual int64_t Write(const void* buffer, int64_t num_bytes) = 0;
-
- // ReadFully and WriteFully do attempt to transfer all of the bytes to/from
- // the buffer. In the event of short accesses they will loop internally until
- // the whole buffer has been transferred or an error occurs. If an error
- // occurred the result will be set to false.
- virtual bool ReadFully(void* buffer, int64_t num_bytes);
- virtual bool WriteFully(const void* buffer, int64_t num_bytes);
- bool WriteByte(uint8_t byte) {
- return WriteFully(&byte, 1);
- }
-
- // Get the length of the file. Returns a negative value if the length cannot
- // be determined (e.g. not seekable device).
- virtual off_t Length() = 0;
-
- // Get the current position in the file.
- // Returns a negative value if position cannot be determined.
- virtual off_t Position() = 0;
-
- virtual int Fd() = 0;
-
- const char* name() const { return name_; }
-
- protected:
- explicit File(const char* name) : name_(name) { }
- virtual void Close() = 0;
- virtual bool IsClosed() = 0;
-
- private:
- const char* name_;
-};
-
-} // namespace art
-
-#endif // ART_SRC_FILE_H_
diff --git a/src/file_linux.cc b/src/file_linux.cc
deleted file mode 100644
index cd272fb..0000000
--- a/src/file_linux.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "file_linux.h"
-
-#include <errno.h>
-#include <unistd.h>
-
-#include "logging.h"
-
-namespace art {
-
-LinuxFile::~LinuxFile() {
- // Close the file if necessary (unless it's a standard stream).
- if (auto_close_ && fd_ > STDERR_FILENO) {
- Close();
- }
-}
-
-void LinuxFile::Close() {
- DCHECK_GT(fd_, 0);
- int err = close(fd_);
- if (err != 0) {
- PLOG(WARNING) << "Problem closing " << name();
- }
- fd_ = kClosedFd;
-}
-
-
-bool LinuxFile::IsClosed() {
- return fd_ == kClosedFd;
-}
-
-
-int64_t LinuxFile::Read(void* buffer, int64_t num_bytes) {
- DCHECK_GE(fd_, 0);
- return read(fd_, buffer, num_bytes);
-}
-
-
-int64_t LinuxFile::Write(const void* buffer, int64_t num_bytes) {
- DCHECK_GE(fd_, 0);
- return write(fd_, buffer, num_bytes);
-}
-
-
-off_t LinuxFile::Position() {
- DCHECK_GE(fd_, 0);
- return lseek(fd_, 0, SEEK_CUR);
-}
-
-
-off_t LinuxFile::Length() {
- DCHECK_GE(fd_, 0);
- off_t position = lseek(fd_, 0, SEEK_CUR);
- if (position < 0) {
- // The file is not capable of seeking. Return an error.
- return -1;
- }
- off_t result = lseek(fd_, 0, SEEK_END);
- lseek(fd_, position, SEEK_SET);
- return result;
-}
-
-} // namespace art
diff --git a/src/file_linux.h b/src/file_linux.h
deleted file mode 100644
index b5d6f3b..0000000
--- a/src/file_linux.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ART_SRC_FILE_LINUX_H_
-#define ART_SRC_FILE_LINUX_H_
-
-#include "file.h"
-
-namespace art {
-
-class LinuxFile : public File {
- public:
- LinuxFile(const char* name, int fd, bool auto_close)
- : File(name), fd_(fd), auto_close_(auto_close) {}
- virtual ~LinuxFile();
-
- virtual void Close();
- virtual bool IsClosed();
-
- virtual int64_t Read(void* buffer, int64_t num_bytes);
- virtual int64_t Write(const void* buffer, int64_t num_bytes);
-
- virtual off_t Length();
- virtual off_t Position();
-
- virtual int Fd() {
- return fd_;
- }
-
- private:
- static const int kClosedFd = -1;
-
- int fd_;
- bool auto_close_;
-};
-
-} // namespace art
-
-#endif // ART_SRC_FILE_LINUX_H_
diff --git a/src/file_test.cc b/src/file_test.cc
deleted file mode 100644
index 85c130e..0000000
--- a/src/file_test.cc
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "file.h"
-
-#include "UniquePtr.h"
-#include "common_test.h"
-#include "os.h"
-
-namespace art {
-
-class FileTest : public CommonTest {};
-
-TEST_F(FileTest, Read) {
- std::string filename(GetLibCoreDexFileName());
- UniquePtr<File> file(OS::OpenFile(filename.c_str(), false));
- ASSERT_TRUE(file.get() != NULL);
- EXPECT_STREQ(filename.c_str(), file->name());
- char buffer[3];
- buffer[0] = '\0';
- EXPECT_TRUE(file->ReadFully(buffer, 2)); // ReadFully returns true.
- buffer[2] = '\0';
- EXPECT_STREQ("PK", buffer); // zip file magic
- EXPECT_FALSE(file->WriteByte(1)); // Cannot write to a read-only file.
-}
-
-
-TEST_F(FileTest, FileLength) {
- std::string filename(GetLibCoreDexFileName());
- UniquePtr<File> file(OS::OpenFile(filename.c_str(), false));
- ASSERT_TRUE(file.get() != NULL);
- EXPECT_NE(0, file->Length());
-}
-
-
-TEST_F(FileTest, FilePosition) {
- std::string filename(GetLibCoreDexFileName());
- UniquePtr<File> file(OS::OpenFile(filename.c_str(), false));
- ASSERT_TRUE(file.get() != NULL);
- char buf[4];
- EXPECT_TRUE(file->ReadFully(buf, 2));
- EXPECT_EQ(2, file->Position());
- EXPECT_TRUE(file->ReadFully(buf, 2));
- EXPECT_EQ(4, file->Position());
-}
-
-
-TEST_F(FileTest, FileFd) {
- std::string filename(GetLibCoreDexFileName());
- UniquePtr<File> file(OS::OpenFile(filename.c_str(), false));
- ASSERT_TRUE(file.get() != NULL);
- EXPECT_NE(-1, file->Fd());
-}
-
-
-} // namespace art
diff --git a/src/gc/atomic_stack.h b/src/gc/atomic_stack.h
index d67d2f2..4a7920e 100644
--- a/src/gc/atomic_stack.h
+++ b/src/gc/atomic_stack.h
@@ -20,9 +20,9 @@
#include <string>
#include "atomic_integer.h"
+#include "base/macros.h"
#include "UniquePtr.h"
#include "logging.h"
-#include "macros.h"
#include "mem_map.h"
#include "utils.h"
diff --git a/src/gc/large_object_space.cc b/src/gc/large_object_space.cc
index b2e0d2f..a994479 100644
--- a/src/gc/large_object_space.cc
+++ b/src/gc/large_object_space.cc
@@ -17,7 +17,6 @@
#include "large_object_space.h"
#include "UniquePtr.h"
#include "dlmalloc.h"
-#include "file.h"
#include "image.h"
#include "logging.h"
#include "os.h"
diff --git a/src/gc/mark_sweep.cc b/src/gc/mark_sweep.cc
index d5231ec..f57d615 100644
--- a/src/gc/mark_sweep.cc
+++ b/src/gc/mark_sweep.cc
@@ -22,6 +22,7 @@
#include <vector>
#include "barrier.h"
+#include "base/macros.h"
#include "card_table.h"
#include "class_loader.h"
#include "dex_cache.h"
@@ -31,7 +32,6 @@
#include "jni_internal.h"
#include "large_object_space.h"
#include "logging.h"
-#include "macros.h"
#include "monitor.h"
#include "object.h"
#include "runtime.h"
diff --git a/src/gc/mark_sweep.h b/src/gc/mark_sweep.h
index c740bb7..3581d98 100644
--- a/src/gc/mark_sweep.h
+++ b/src/gc/mark_sweep.h
@@ -18,8 +18,8 @@
#define ART_SRC_MARK_SWEEP_H_
#include "atomic_stack.h"
+#include "base/macros.h"
#include "garbage_collector.h"
-#include "macros.h"
#include "heap_bitmap.h"
#include "object.h"
#include "offsets.h"
diff --git a/src/gc/space.cc b/src/gc/space.cc
index 8595dd0..27f78cc 100644
--- a/src/gc/space.cc
+++ b/src/gc/space.cc
@@ -17,8 +17,8 @@
#include "space.h"
#include "UniquePtr.h"
+#include "base/unix_file/fd_file.h"
#include "dlmalloc.h"
-#include "file.h"
#include "image.h"
#include "logging.h"
#include "os.h"
@@ -485,7 +485,7 @@
return NULL;
}
UniquePtr<MemMap> map(MemMap::MapFileAtAddress(image_header.GetImageBegin(),
- file->Length(),
+ file->GetLength(),
// TODO: selectively PROT_EXEC stubs
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_FIXED,
diff --git a/src/gc/space.h b/src/gc/space.h
index dfbc9d2..24427f1 100644
--- a/src/gc/space.h
+++ b/src/gc/space.h
@@ -21,9 +21,9 @@
#include "../mutex.h"
#include "UniquePtr.h"
+#include "base/macros.h"
#include "globals.h"
#include "image.h"
-#include "macros.h"
#include "dlmalloc.h"
#include "mem_map.h"
diff --git a/src/gc/sticky_mark_sweep.h b/src/gc/sticky_mark_sweep.h
index 9c3b6a4..8396bbe 100644
--- a/src/gc/sticky_mark_sweep.h
+++ b/src/gc/sticky_mark_sweep.h
@@ -17,8 +17,8 @@
#ifndef ART_SRC_STICKY_MARK_SWEEP_H_
#define ART_SRC_STICKY_MARK_SWEEP_H_
+#include "base/macros.h"
#include "locks.h"
-#include "macros.h"
#include "partial_mark_sweep.h"
#include "utils.h"
diff --git a/src/gc_map.h b/src/gc_map.h
index afccaa1..80810b0 100644
--- a/src/gc_map.h
+++ b/src/gc_map.h
@@ -17,8 +17,8 @@
#ifndef ART_SRC_GC_MAP_H_
#define ART_SRC_GC_MAP_H_
+#include "base/macros.h"
#include "logging.h"
-#include "macros.h"
#include <stdint.h>
namespace art {
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index 6965015..8838c29 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -37,9 +37,9 @@
#include <set>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "debugger.h"
-#include "file.h"
#include "globals.h"
#include "heap.h"
#include "logging.h"
@@ -459,7 +459,7 @@
}
}
- UniquePtr<File> file(OS::FileFromFd(filename_.c_str(), out_fd));
+ UniquePtr<File> file(new File(out_fd, filename_));
okay = file->WriteFully(header_data_ptr_, header_data_size_) &&
file->WriteFully(body_data_ptr_, body_data_size_);
if (!okay) {
@@ -468,7 +468,6 @@
self->ThrowNewException("Ljava/lang/RuntimeException;", msg.c_str());
LOG(ERROR) << msg;
}
- close(out_fd);
}
// Throw out a log message for the benefit of "runhat".
diff --git a/src/image_test.cc b/src/image_test.cc
index feb490c..a250b13 100644
--- a/src/image_test.cc
+++ b/src/image_test.cc
@@ -18,7 +18,6 @@
#include <vector>
#include "common_test.h"
-#include "file.h"
#include "image.h"
#include "image_writer.h"
#include "oat_writer.h"
@@ -71,7 +70,7 @@
ASSERT_FALSE(space->IsImageSpace());
ASSERT_TRUE(space != NULL);
ASSERT_TRUE(space->IsAllocSpace());
- ASSERT_GE(sizeof(image_header) + space->Size(), static_cast<size_t>(file->Length()));
+ ASSERT_GE(sizeof(image_header) + space->Size(), static_cast<size_t>(file->GetLength()));
}
// Need to delete the compiler since it has worker threads which are attached to runtime.
diff --git a/src/image_writer.cc b/src/image_writer.cc
index a9aa2e0..6065760 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -20,12 +20,12 @@
#include <vector>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "class_loader.h"
#include "compiled_method.h"
#include "compiler.h"
#include "dex_cache.h"
-#include "file.h"
#include "gc/large_object_space.h"
#include "gc/space.h"
#include "globals.h"
diff --git a/src/indenter.h b/src/indenter.h
index f66df08..4ac0c01 100644
--- a/src/indenter.h
+++ b/src/indenter.h
@@ -17,7 +17,7 @@
#ifndef ART_SRC_INDENTER_H_
#define ART_SRC_INDENTER_H_
-#include "macros.h"
+#include "base/macros.h"
#include <streambuf>
const char kIndentChar =' ';
diff --git a/src/instrumentation.cc b/src/instrumentation.cc
index d796aef..28f8cb2 100644
--- a/src/instrumentation.cc
+++ b/src/instrumentation.cc
@@ -18,6 +18,7 @@
#include <sys/uio.h>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "debugger.h"
#include "dex_cache.h"
diff --git a/src/instrumentation.h b/src/instrumentation.h
index a5ab650..b17e020 100644
--- a/src/instrumentation.h
+++ b/src/instrumentation.h
@@ -21,9 +21,8 @@
#include <set>
#include <string>
-#include "file.h"
+#include "base/macros.h"
#include "globals.h"
-#include "macros.h"
#include "safe_map.h"
#include "trace.h"
#include "UniquePtr.h"
diff --git a/src/jdwp/jdwp_handler.cc b/src/jdwp/jdwp_handler.cc
index 88677d5..2a2bde2 100644
--- a/src/jdwp/jdwp_handler.cc
+++ b/src/jdwp/jdwp_handler.cc
@@ -26,6 +26,7 @@
*/
#include "atomic.h"
+#include "base/macros.h"
#include "debugger.h"
#include "jdwp/jdwp_priv.h"
#include "jdwp/jdwp_handler.h"
@@ -33,7 +34,6 @@
#include "jdwp/jdwp_constants.h"
#include "jdwp/jdwp_expand_buf.h"
#include "logging.h"
-#include "macros.h"
#include "stringprintf.h"
#include <stdlib.h>
diff --git a/src/jni_internal.h b/src/jni_internal.h
index 95bc281..606887c 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -19,9 +19,9 @@
#include "jni.h"
+#include "base/macros.h"
#include "heap.h"
#include "indirect_reference_table.h"
-#include "macros.h"
#include "mutex.h"
#include "reference_table.h"
#include "runtime.h"
diff --git a/src/locks.h b/src/locks.h
index 9da7711..6f8400d 100644
--- a/src/locks.h
+++ b/src/locks.h
@@ -19,7 +19,7 @@
#include <ostream>
-#include "macros.h"
+#include "base/macros.h"
namespace art {
diff --git a/src/logging.h b/src/logging.h
index 1c04b2c..55dc710 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -22,8 +22,8 @@
#include <iostream> // NOLINT
#include <sstream>
#include <signal.h>
+#include "base/macros.h"
#include "log_severity.h"
-#include "macros.h"
#define CHECK(x) \
if (UNLIKELY(!(x))) \
diff --git a/src/memory_region.h b/src/memory_region.h
index 5a7eab6..bd1ae87 100644
--- a/src/memory_region.h
+++ b/src/memory_region.h
@@ -18,9 +18,10 @@
#define ART_SRC_MEMORY_REGION_H_
#include <stdint.h>
+
+#include "base/macros.h"
#include "globals.h"
#include "logging.h"
-#include "macros.h"
#include "memory_region.h"
namespace art {
diff --git a/src/mutex.h b/src/mutex.h
index 9e337ec..6cfd4b9 100644
--- a/src/mutex.h
+++ b/src/mutex.h
@@ -23,10 +23,10 @@
#include <iosfwd>
#include <string>
+#include "base/macros.h"
#include "globals.h"
#include "locks.h"
#include "logging.h"
-#include "macros.h"
#if defined(__APPLE__)
#define ART_USE_FUTEXES 0
diff --git a/src/oat.h b/src/oat.h
index 254be1a..1f12b54 100644
--- a/src/oat.h
+++ b/src/oat.h
@@ -19,9 +19,9 @@
#include <vector>
+#include "base/macros.h"
#include "dex_file.h"
#include "instruction_set.h"
-#include "macros.h"
namespace art {
diff --git a/src/oat/jni/jni_compiler.cc b/src/oat/jni/jni_compiler.cc
index 585d60e..5a2243e 100644
--- a/src/oat/jni/jni_compiler.cc
+++ b/src/oat/jni/jni_compiler.cc
@@ -17,6 +17,7 @@
#include <algorithm>
#include <vector>
+#include "base/macros.h"
#include "calling_convention.h"
#include "class_linker.h"
#include "compiled_method.h"
@@ -24,7 +25,6 @@
#include "disassembler.h"
#include "jni_internal.h"
#include "logging.h"
-#include "macros.h"
#include "oat/runtime/oat_support_entrypoints.h"
#include "oat/utils/assembler.h"
#include "oat/utils/managed_register.h"
diff --git a/src/oat/utils/assembler.h b/src/oat/utils/assembler.h
index 0880d57..c05309a 100644
--- a/src/oat/utils/assembler.h
+++ b/src/oat/utils/assembler.h
@@ -19,12 +19,12 @@
#include <vector>
+#include "base/macros.h"
#include "constants_arm.h"
#include "constants_mips.h"
#include "constants_x86.h"
#include "instruction_set.h"
#include "logging.h"
-#include "macros.h"
#include "managed_register.h"
#include "memory_region.h"
#include "offsets.h"
diff --git a/src/oat/utils/mips/assembler_mips.h b/src/oat/utils/mips/assembler_mips.h
index 73937aa..02759e4 100644
--- a/src/oat/utils/mips/assembler_mips.h
+++ b/src/oat/utils/mips/assembler_mips.h
@@ -18,10 +18,11 @@
#define ART_SRC_OAT_UTILS_MIPS_ASSEMBLER_MIPS_H_
#include <vector>
+
+#include "base/macros.h"
#include "constants_mips.h"
#include "globals.h"
#include "managed_register_mips.h"
-#include "macros.h"
#include "oat/utils/assembler.h"
#include "offsets.h"
#include "utils.h"
diff --git a/src/oat/utils/x86/assembler_x86.h b/src/oat/utils/x86/assembler_x86.h
index 5971fe8..dddb9b1 100644
--- a/src/oat/utils/x86/assembler_x86.h
+++ b/src/oat/utils/x86/assembler_x86.h
@@ -18,10 +18,10 @@
#define ART_SRC_OAT_UTILS_X86_ASSEMBLER_X86_H_
#include <vector>
+#include "base/macros.h"
#include "constants_x86.h"
#include "globals.h"
#include "managed_register_x86.h"
-#include "macros.h"
#include "oat/utils/assembler.h"
#include "offsets.h"
#include "utils.h"
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 145d2e2..04ee545 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -16,7 +16,7 @@
#include "oat_file.h"
-#include "file.h"
+#include "base/unix_file/fd_file.h"
#include "os.h"
#include "stl_util.h"
@@ -92,33 +92,33 @@
flags |= MAP_FIXED;
}
UniquePtr<MemMap> map(MemMap::MapFileAtAddress(requested_base,
- file.Length(),
+ file.GetLength(),
prot,
flags,
file.Fd(),
0));
if (map.get() == NULL) {
- LOG(WARNING) << "Failed to map oat file from " << file.name() << " for " << GetLocation();
+ LOG(WARNING) << "Failed to map oat file from " << file.GetPath() << " for " << GetLocation();
return false;
}
CHECK(requested_base == 0 || requested_base == map->Begin())
- << file.name() << " for " << GetLocation() << " " << reinterpret_cast<void*>(map->Begin());
+ << file.GetPath() << " for " << GetLocation() << " " << reinterpret_cast<void*>(map->Begin());
DCHECK_EQ(0, memcmp(&oat_header, map->Begin(), sizeof(OatHeader)))
- << file.name() << " for " << GetLocation();
+ << file.GetPath() << " for " << GetLocation();
off_t code_offset = oat_header.GetExecutableOffset();
- if (code_offset < file.Length()) {
+ if (code_offset < file.GetLength()) {
byte* code_address = map->Begin() + code_offset;
- size_t code_length = file.Length() - code_offset;
+ size_t code_length = file.GetLength() - code_offset;
if (mprotect(code_address, code_length, prot | PROT_EXEC) != 0) {
PLOG(ERROR) << "Failed to make oat code executable in "
- << file.name() << " for " << GetLocation();
+ << file.GetPath() << " for " << GetLocation();
return false;
}
} else {
// its possible to have no code if all the methods were abstract, native, etc
- DCHECK_EQ(code_offset, RoundUp(file.Length(), kPageSize))
- << file.name() << " for " << GetLocation();
+ DCHECK_EQ(code_offset, RoundUp(file.GetLength(), kPageSize))
+ << file.GetPath() << " for " << GetLocation();
}
const byte* oat = map->Begin();
@@ -131,40 +131,40 @@
<< "+" << sizeof(OatHeader)
<< "+" << oat_header.GetImageFileLocationSize()
<< "<=" << reinterpret_cast<void*>(map->End())
- << " " << file.name() << " for " << GetLocation();
+ << " " << file.GetPath() << " for " << GetLocation();
for (size_t i = 0; i < oat_header.GetDexFileCount(); i++) {
size_t dex_file_location_size = *reinterpret_cast<const uint32_t*>(oat);
- CHECK_GT(dex_file_location_size, 0U) << file.name() << " for " << GetLocation();
+ CHECK_GT(dex_file_location_size, 0U) << file.GetPath() << " for " << GetLocation();
oat += sizeof(dex_file_location_size);
- CHECK_LT(oat, map->End()) << file.name() << " for " << GetLocation();
+ CHECK_LT(oat, map->End()) << file.GetPath() << " for " << GetLocation();
const char* dex_file_location_data = reinterpret_cast<const char*>(oat);
oat += dex_file_location_size;
- CHECK_LT(oat, map->End()) << file.name() << " for " << GetLocation();
+ CHECK_LT(oat, map->End()) << file.GetPath() << " for " << GetLocation();
std::string dex_file_location(dex_file_location_data, dex_file_location_size);
uint32_t dex_file_checksum = *reinterpret_cast<const uint32_t*>(oat);
oat += sizeof(dex_file_checksum);
- CHECK_LT(oat, map->End()) << file.name() << " for " << GetLocation();
+ CHECK_LT(oat, map->End()) << file.GetPath() << " for " << GetLocation();
uint32_t dex_file_offset = *reinterpret_cast<const uint32_t*>(oat);
- CHECK_GT(dex_file_offset, 0U) << file.name() << " for " << GetLocation();
- CHECK_LT(dex_file_offset, static_cast<uint32_t>(file.Length()))
- << file.name() << " for " << GetLocation();
+ CHECK_GT(dex_file_offset, 0U) << file.GetPath() << " for " << GetLocation();
+ CHECK_LT(dex_file_offset, static_cast<uint32_t>(file.GetLength()))
+ << file.GetPath() << " for " << GetLocation();
oat += sizeof(dex_file_offset);
- CHECK_LT(oat, map->End()) << file.name() << " for " << GetLocation();
+ CHECK_LT(oat, map->End()) << file.GetPath() << " for " << GetLocation();
uint8_t* dex_file_pointer = map->Begin() + dex_file_offset;
CHECK(DexFile::IsMagicValid(dex_file_pointer))
- << file.name() << " for " << GetLocation() << " " << dex_file_pointer;
+ << file.GetPath() << " for " << GetLocation() << " " << dex_file_pointer;
CHECK(DexFile::IsVersionValid(dex_file_pointer))
- << file.name() << " for " << GetLocation() << " " << dex_file_pointer;
+ << file.GetPath() << " for " << GetLocation() << " " << dex_file_pointer;
const DexFile::Header* header = reinterpret_cast<const DexFile::Header*>(dex_file_pointer);
const uint32_t* methods_offsets_pointer = reinterpret_cast<const uint32_t*>(oat);
oat += (sizeof(*methods_offsets_pointer) * header->class_defs_size_);
- CHECK_LE(oat, map->End()) << file.name() << " for " << GetLocation();
+ CHECK_LE(oat, map->End()) << file.GetPath() << " for " << GetLocation();
oat_dex_files_.Put(dex_file_location, new OatDexFile(this,
dex_file_location,
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index a15c5cf..49d4e25 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -18,9 +18,9 @@
#include <zlib.h>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "class_loader.h"
-#include "file.h"
#include "os.h"
#include "safe_map.h"
#include "scoped_thread_state_change.h"
@@ -425,30 +425,30 @@
bool OatWriter::Write(File* file) {
if (!file->WriteFully(oat_header_, sizeof(*oat_header_))) {
- PLOG(ERROR) << "Failed to write oat header to " << file->name();
+ PLOG(ERROR) << "Failed to write oat header to " << file->GetPath();
return false;
}
if (!file->WriteFully(image_file_location_.data(),
image_file_location_.size())) {
- PLOG(ERROR) << "Failed to write oat header image file location to " << file->name();
+ PLOG(ERROR) << "Failed to write oat header image file location to " << file->GetPath();
return false;
}
if (!WriteTables(file)) {
- LOG(ERROR) << "Failed to write oat tables to " << file->name();
+ LOG(ERROR) << "Failed to write oat tables to " << file->GetPath();
return false;
}
size_t code_offset = WriteCode(file);
if (code_offset == 0) {
- LOG(ERROR) << "Failed to write oat code to " << file->name();
+ LOG(ERROR) << "Failed to write oat code to " << file->GetPath();
return false;
}
code_offset = WriteCodeDexFiles(file, code_offset);
if (code_offset == 0) {
- LOG(ERROR) << "Failed to write oat code for dex files to " << file->name();
+ LOG(ERROR) << "Failed to write oat code for dex files to " << file->GetPath();
return false;
}
@@ -458,7 +458,7 @@
bool OatWriter::WriteTables(File* file) {
for (size_t i = 0; i != oat_dex_files_.size(); ++i) {
if (!oat_dex_files_[i]->Write(file)) {
- PLOG(ERROR) << "Failed to write oat dex information to " << file->name();
+ PLOG(ERROR) << "Failed to write oat dex information to " << file->GetPath();
return false;
}
}
@@ -473,13 +473,13 @@
}
const DexFile* dex_file = (*dex_files_)[i];
if (!file->WriteFully(&dex_file->GetHeader(), dex_file->GetHeader().file_size_)) {
- PLOG(ERROR) << "Failed to write dex file " << dex_file->GetLocation() << " to " << file->name();
+ PLOG(ERROR) << "Failed to write dex file " << dex_file->GetLocation() << " to " << file->GetPath();
return false;
}
}
for (size_t i = 0; i != oat_classes_.size(); ++i) {
if (!oat_classes_[i]->Write(file)) {
- PLOG(ERROR) << "Failed to write oat methods information to " << file->name();
+ PLOG(ERROR) << "Failed to write oat methods information to " << file->GetPath();
return false;
}
}
@@ -491,7 +491,7 @@
off_t new_offset = lseek(file->Fd(), executable_offset_padding_length_, SEEK_CUR);
if (static_cast<uint32_t>(new_offset) != code_offset) {
PLOG(ERROR) << "Failed to seek to oat code section. Actual: " << new_offset
- << " Expected: " << code_offset << " File: " << file->name();
+ << " Expected: " << code_offset << " File: " << file->GetPath();
return 0;
}
DCHECK_CODE_OFFSET();
@@ -527,7 +527,7 @@
void OatWriter::ReportWriteFailure(const char* what, uint32_t method_idx,
const DexFile& dex_file, File* f) const {
PLOG(ERROR) << "Failed to write " << what << " for " << PrettyMethod(method_idx, dex_file)
- << " to " << f->name();
+ << " to " << f->GetPath();
}
size_t OatWriter::WriteCodeClassDef(File* file,
@@ -588,7 +588,7 @@
off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
- << " Expected: " << aligned_code_offset << " File: " << file->name();
+ << " Expected: " << aligned_code_offset << " File: " << file->GetPath();
return 0;
}
code_offset += aligned_code_delta;
@@ -813,24 +813,24 @@
bool OatWriter::OatDexFile::Write(File* file) const {
if (!file->WriteFully(&dex_file_location_size_, sizeof(dex_file_location_size_))) {
- PLOG(ERROR) << "Failed to write dex file location length to " << file->name();
+ PLOG(ERROR) << "Failed to write dex file location length to " << file->GetPath();
return false;
}
if (!file->WriteFully(dex_file_location_data_, dex_file_location_size_)) {
- PLOG(ERROR) << "Failed to write dex file location data to " << file->name();
+ PLOG(ERROR) << "Failed to write dex file location data to " << file->GetPath();
return false;
}
if (!file->WriteFully(&dex_file_location_checksum_, sizeof(dex_file_location_checksum_))) {
- PLOG(ERROR) << "Failed to write dex file location checksum to " << file->name();
+ PLOG(ERROR) << "Failed to write dex file location checksum to " << file->GetPath();
return false;
}
if (!file->WriteFully(&dex_file_offset_, sizeof(dex_file_offset_))) {
- PLOG(ERROR) << "Failed to write dex file offset to " << file->name();
+ PLOG(ERROR) << "Failed to write dex file offset to " << file->GetPath();
return false;
}
if (!file->WriteFully(&methods_offsets_[0],
sizeof(methods_offsets_[0]) * methods_offsets_.size())) {
- PLOG(ERROR) << "Failed to write methods offsets to " << file->name();
+ PLOG(ERROR) << "Failed to write methods offsets to " << file->GetPath();
return false;
}
return true;
@@ -854,12 +854,12 @@
bool OatWriter::OatClass::Write(File* file) const {
if (!file->WriteFully(&status_, sizeof(status_))) {
- PLOG(ERROR) << "Failed to write class status to " << file->name();
+ PLOG(ERROR) << "Failed to write class status to " << file->GetPath();
return false;
}
if (!file->WriteFully(&method_offsets_[0],
sizeof(method_offsets_[0]) * method_offsets_.size())) {
- PLOG(ERROR) << "Failed to write method offsets to " << file->name();
+ PLOG(ERROR) << "Failed to write method offsets to " << file->GetPath();
return false;
}
return true;
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 45d936a..cd8b4bb 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -22,10 +22,10 @@
#include <string>
#include <vector>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "dex_instruction.h"
#include "disassembler.h"
-#include "file.h"
#include "gc_map.h"
#include "gc/large_object_space.h"
#include "gc/space.h"
@@ -792,7 +792,7 @@
}
os << "STATS:\n" << std::flush;
UniquePtr<File> file(OS::OpenFile(image_filename_.c_str(), false));
- stats_.file_bytes = file->Length();
+ stats_.file_bytes = file->GetLength();
size_t header_bytes = sizeof(ImageHeader);
stats_.header_bytes = header_bytes;
size_t alignment_bytes = RoundUp(header_bytes, kObjectAlignment) - header_bytes;
diff --git a/src/object.h b/src/object.h
index e9851c0..a3b808f 100644
--- a/src/object.h
+++ b/src/object.h
@@ -22,12 +22,12 @@
#include "UniquePtr.h"
#include "atomic.h"
+#include "base/macros.h"
#include "casts.h"
#include "globals.h"
#include "heap.h"
#include "invoke_type.h"
#include "logging.h"
-#include "macros.h"
#include "modifiers.h"
#include "offsets.h"
#include "primitive.h"
diff --git a/src/os.h b/src/os.h
index 33552ad..3428b6a 100644
--- a/src/os.h
+++ b/src/os.h
@@ -17,20 +17,21 @@
#ifndef ART_SRC_OS_H_
#define ART_SRC_OS_H_
+namespace unix_file {
+class FdFile;
+} // namespace unix_file
+
namespace art {
+typedef ::unix_file::FdFile File;
+
// Interface to the underlying OS platform.
-class File;
-
class OS {
public:
- // Open a file. The returned file must be deleted by the caller.
+ // Open a file. The returned pointer must be deleted by the caller.
static File* OpenFile(const char* name, bool writable, bool create = true);
- // Create a file from an already open file descriptor
- static File* FileFromFd(const char* name, int fd);
-
// Check if a file exists.
static bool FileExists(const char* name);
diff --git a/src/os_linux.cc b/src/os_linux.cc
index b91f1ff..ceda7dd 100644
--- a/src/os_linux.cc
+++ b/src/os_linux.cc
@@ -21,7 +21,8 @@
#include <sys/stat.h>
#include <fcntl.h>
-#include "file_linux.h"
+#include "base/unix_file/fd_file.h"
+#include "UniquePtr.h"
namespace art {
@@ -35,15 +36,11 @@
} else {
flags |= O_RDONLY;
}
- int fd = open(name, flags, 0666);
- if (fd < 0) {
+ UniquePtr<File> file(new File);
+ if (!file->Open(name, flags, 0666)) {
return NULL;
}
- return new LinuxFile(name, fd, true);
-}
-
-File* OS::FileFromFd(const char* name, int fd) {
- return new LinuxFile(name, fd, false);
+ return file.release();
}
bool OS::FileExists(const char* name) {
diff --git a/src/primitive.h b/src/primitive.h
index ae2e487..d0caeca 100644
--- a/src/primitive.h
+++ b/src/primitive.h
@@ -19,8 +19,8 @@
#include <sys/types.h>
+#include "base/macros.h"
#include "logging.h"
-#include "macros.h"
namespace art {
diff --git a/src/runtime.h b/src/runtime.h
index c596a17..c8a520a 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -25,11 +25,11 @@
#include <utility>
#include <vector>
+#include "base/macros.h"
#include "globals.h"
#include "heap.h"
#include "instruction_set.h"
#include "jobject_comparator.h"
-#include "macros.h"
#include "locks.h"
#include "runtime_stats.h"
#include "safe_map.h"
diff --git a/src/runtime_linux.cc b/src/runtime_linux.cc
index 72989a6..e2050d1 100644
--- a/src/runtime_linux.cc
+++ b/src/runtime_linux.cc
@@ -34,7 +34,7 @@
}
};
-struct OS {
+struct OsInfo {
void Dump(std::ostream& os) {
utsname info;
uname(&info);
@@ -242,7 +242,7 @@
bool has_address = (signal_number == SIGILL || signal_number == SIGBUS ||
signal_number == SIGFPE || signal_number == SIGSEGV);
- OS os_info;
+ OsInfo os_info;
const char* cmd_line = GetCmdLine();
if (cmd_line == NULL) {
cmd_line = "<unset>"; // Because no-one called InitLogging.
@@ -258,7 +258,7 @@
info->si_code,
GetSignalCodeName(signal_number, info->si_code))
<< (has_address ? StringPrintf(" fault addr %p", info->si_addr) : "") << "\n"
- << "OS: " << Dumpable<OS>(os_info) << "\n"
+ << "OS: " << Dumpable<OsInfo>(os_info) << "\n"
<< "Cmdline: " << cmd_line << "\n"
<< "Thread: " << tid << " \"" << thread_name << "\"\n"
<< "Registers:\n" << Dumpable<UContext>(thread_context) << "\n"
diff --git a/src/signal_catcher.cc b/src/signal_catcher.cc
index db0d2c7..9fdf4e9 100644
--- a/src/signal_catcher.cc
+++ b/src/signal_catcher.cc
@@ -25,8 +25,8 @@
#include <sys/types.h>
#include <unistd.h>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
-#include "file.h"
#include "heap.h"
#include "os.h"
#include "runtime.h"
@@ -106,13 +106,12 @@
PLOG(ERROR) << "Unable to open stack trace file '" << stack_trace_file_ << "'";
return;
}
- UniquePtr<File> file(OS::FileFromFd(stack_trace_file_.c_str(), fd));
+ UniquePtr<File> file(new File(fd, stack_trace_file_));
if (!file->WriteFully(s.data(), s.size())) {
PLOG(ERROR) << "Failed to write stack traces to '" << stack_trace_file_ << "'";
} else {
LOG(INFO) << "Wrote stack traces to '" << stack_trace_file_ << "'";
}
- close(fd);
}
void SignalCatcher::HandleSigQuit() {
diff --git a/src/sirt_ref.h b/src/sirt_ref.h
index ea0b9a3..5e29214 100644
--- a/src/sirt_ref.h
+++ b/src/sirt_ref.h
@@ -17,8 +17,8 @@
#ifndef ART_SRC_SIRT_REF_H_
#define ART_SRC_SIRT_REF_H_
+#include "base/macros.h"
#include "logging.h"
-#include "macros.h"
#include "thread.h"
namespace art {
diff --git a/src/stack.h b/src/stack.h
index ecfa846..30de26d 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -17,11 +17,11 @@
#ifndef ART_SRC_STACK_H_
#define ART_SRC_STACK_H_
+#include "base/macros.h"
#include "dex_file.h"
#include "heap.h"
#include "instrumentation.h"
#include "jni.h"
-#include "macros.h"
#include "oat/runtime/context.h"
#include <stdint.h>
diff --git a/src/stack_indirect_reference_table.h b/src/stack_indirect_reference_table.h
index 506f00a..a9d305a 100644
--- a/src/stack_indirect_reference_table.h
+++ b/src/stack_indirect_reference_table.h
@@ -17,8 +17,8 @@
#ifndef ART_SRC_STACK_INDIRECT_REFERENCE_TABLE_H_
#define ART_SRC_STACK_INDIRECT_REFERENCE_TABLE_H_
+#include "base/macros.h"
#include "logging.h"
-#include "macros.h"
namespace art {
diff --git a/src/thread.h b/src/thread.h
index 4d97315..29ae7c1 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -25,10 +25,10 @@
#include <string>
#include <vector>
+#include "base/macros.h"
#include "closure.h"
#include "globals.h"
#include "instrumentation.h"
-#include "macros.h"
#include "oat/runtime/oat_support_entrypoints.h"
#include "locks.h"
#include "offsets.h"
diff --git a/src/thread_android.cc b/src/thread_android.cc
index f86d0f4..7c4551f 100644
--- a/src/thread_android.cc
+++ b/src/thread_android.cc
@@ -24,7 +24,7 @@
#include <cutils/sched_policy.h>
#include <utils/threads.h>
-#include "macros.h"
+#include "base/macros.h"
namespace art {
diff --git a/src/thread_arm.cc b/src/thread_arm.cc
index bc343ed..0ef26bf 100644
--- a/src/thread_arm.cc
+++ b/src/thread_arm.cc
@@ -17,7 +17,7 @@
#include "thread.h"
#include "asm_support.h"
-#include "macros.h"
+#include "base/macros.h"
namespace art {
diff --git a/src/thread_mips.cc b/src/thread_mips.cc
index bc343ed..0ef26bf 100644
--- a/src/thread_mips.cc
+++ b/src/thread_mips.cc
@@ -17,7 +17,7 @@
#include "thread.h"
#include "asm_support.h"
-#include "macros.h"
+#include "base/macros.h"
namespace art {
diff --git a/src/thread_x86.cc b/src/thread_x86.cc
index c841235..959f317 100644
--- a/src/thread_x86.cc
+++ b/src/thread_x86.cc
@@ -20,7 +20,7 @@
#include <sys/types.h>
#include "asm_support.h"
-#include "macros.h"
+#include "base/macros.h"
#include "thread.h"
#include "thread_list.h"
diff --git a/src/trace.cc b/src/trace.cc
index f04b1db..7b3cea8 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -18,6 +18,7 @@
#include <sys/uio.h>
+#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "debugger.h"
#include "dex_cache.h"
@@ -179,7 +180,8 @@
if (trace_fd < 0) {
trace_file = OS::OpenFile(trace_filename, true);
} else {
- trace_file = OS::FileFromFd("tracefile", trace_fd);
+ trace_file = new File(trace_fd, "tracefile");
+ trace_file->DisableAutoClose();
}
if (trace_file == NULL) {
PLOG(ERROR) << "Unable to open trace file '" << trace_filename << "'";
diff --git a/src/trace.h b/src/trace.h
index 5dd29b9..e3f254e 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -21,9 +21,9 @@
#include <set>
#include <string>
-#include "file.h"
+#include "base/macros.h"
#include "globals.h"
-#include "macros.h"
+#include "os.h"
#include "safe_map.h"
#include "UniquePtr.h"
diff --git a/src/utf.h b/src/utf.h
index 1d4101f..e95289e 100644
--- a/src/utf.h
+++ b/src/utf.h
@@ -17,9 +17,10 @@
#ifndef ART_SRC_UTF_H_
#define ART_SRC_UTF_H_
+#include "base/macros.h"
+
#include <stddef.h>
#include <stdint.h>
-#include "macros.h"
/*
* All UTF-8 in art is actually modified UTF-8. Mostly, this distinction
diff --git a/src/utils.cc b/src/utils.cc
index 3cf6914..78d3599 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -24,8 +24,8 @@
#include <unistd.h>
#include "UniquePtr.h"
+#include "base/unix_file/fd_file.h"
#include "class_loader.h"
-#include "file.h"
#include "object.h"
#include "object_utils.h"
#include "os.h"
@@ -95,14 +95,14 @@
}
bool ReadFileToString(const std::string& file_name, std::string* result) {
- UniquePtr<File> file(OS::OpenFile(file_name.c_str(), false));
- if (file.get() == NULL) {
+ UniquePtr<File> file(new File);
+ if (!file->Open(file_name, O_RDONLY)) {
return false;
}
std::vector<char> buf(8 * KB);
while (true) {
- int64_t n = file->Read(&buf[0], buf.size());
+ int64_t n = TEMP_FAILURE_RETRY(read(file->Fd(), &buf[0], buf.size()));
if (n == -1) {
return false;
}
diff --git a/src/verifier/dex_gc_map.h b/src/verifier/dex_gc_map.h
index d588cfd..540dae8 100644
--- a/src/verifier/dex_gc_map.h
+++ b/src/verifier/dex_gc_map.h
@@ -17,8 +17,8 @@
#ifndef ART_SRC_VERIFIER_DEX_GC_MAP_H_
#define ART_SRC_VERIFIER_DEX_GC_MAP_H_
+#include "base/macros.h"
#include "logging.h"
-#include "macros.h"
#include <stdint.h>
namespace art {
diff --git a/src/verifier/method_verifier.h b/src/verifier/method_verifier.h
index 95d7905..99801c6 100644
--- a/src/verifier/method_verifier.h
+++ b/src/verifier/method_verifier.h
@@ -22,11 +22,11 @@
#include <set>
#include <vector>
+#include "base/macros.h"
#include "casts.h"
#include "compiler.h"
#include "dex_file.h"
#include "dex_instruction.h"
-#include "macros.h"
#include "object.h"
#include "reg_type.h"
#include "reg_type_cache.h"
diff --git a/src/verifier/reg_type.h b/src/verifier/reg_type.h
index 79ff674..c610e06 100644
--- a/src/verifier/reg_type.h
+++ b/src/verifier/reg_type.h
@@ -17,7 +17,7 @@
#ifndef ART_SRC_VERIFIER_REG_TYPE_H_
#define ART_SRC_VERIFIER_REG_TYPE_H_
-#include "macros.h"
+#include "base/macros.h"
#include "object.h"
#include <stdint.h>
diff --git a/src/verifier/reg_type_cache.h b/src/verifier/reg_type_cache.h
index bf0c5b1..c86f65b 100644
--- a/src/verifier/reg_type_cache.h
+++ b/src/verifier/reg_type_cache.h
@@ -17,7 +17,7 @@
#ifndef ART_SRC_VERIFIER_REG_TYPE_CACHE_H_
#define ART_SRC_VERIFIER_REG_TYPE_CACHE_H_
-#include "macros.h"
+#include "base/macros.h"
#include "reg_type.h"
#include "stl_util.h"
diff --git a/src/zip_archive.cc b/src/zip_archive.cc
index 18a2f30..c9e9c0a 100644
--- a/src/zip_archive.cc
+++ b/src/zip_archive.cc
@@ -23,6 +23,7 @@
#include <sys/types.h>
#include <unistd.h>
+#include "base/unix_file/fd_file.h"
#include "UniquePtr.h"
namespace art {
@@ -243,13 +244,13 @@
uint32_t length = GetUncompressedLength();
int result = TEMP_FAILURE_RETRY(ftruncate(file.Fd(), length));
if (result == -1) {
- PLOG(WARNING) << "Zip: failed to ftruncate " << file.name() << " to length " << length;
+ PLOG(WARNING) << "Zip: failed to ftruncate " << file.GetPath() << " to length " << length;
return false;
}
UniquePtr<MemMap> map(MemMap::MapFile(length, PROT_READ | PROT_WRITE, MAP_SHARED, file.Fd(), 0));
if (map.get() == NULL) {
- LOG(WARNING) << "Zip: failed to mmap space for " << file.name();
+ LOG(WARNING) << "Zip: failed to mmap space for " << file.GetPath();
return false;
}
diff --git a/src/zip_archive.h b/src/zip_archive.h
index d7a8d80..65fbdb8 100644
--- a/src/zip_archive.h
+++ b/src/zip_archive.h
@@ -20,10 +20,11 @@
#include <stdint.h>
#include <zlib.h>
-#include "file.h"
+#include "base/unix_file/random_access_file.h"
#include "globals.h"
#include "logging.h"
#include "mem_map.h"
+#include "os.h"
#include "safe_map.h"
#include "stringpiece.h"
#include "UniquePtr.h"
diff --git a/src/zip_archive_test.cc b/src/zip_archive_test.cc
index 7409ec4..9bdc24b 100644
--- a/src/zip_archive_test.cc
+++ b/src/zip_archive_test.cc
@@ -36,11 +36,11 @@
ScratchFile tmp;
ASSERT_NE(-1, tmp.GetFd());
- UniquePtr<File> file(OS::FileFromFd(tmp.GetFilename().c_str(), tmp.GetFd()));
+ UniquePtr<File> file(new File(tmp.GetFd(), tmp.GetFilename()));
ASSERT_TRUE(file.get() != NULL);
bool success = zip_entry->ExtractToFile(*file);
ASSERT_TRUE(success);
- close(tmp.GetFd());
+ file.reset(NULL);
uint32_t computed_crc = crc32(0L, Z_NULL, 0);
int fd = open(tmp.GetFilename().c_str(), O_RDONLY);