| Index: runtime/bin/file_android.cc | 
| diff --git a/runtime/bin/file_android.cc b/runtime/bin/file_android.cc | 
| index 0176ba632fa4f6571e14c14c937161ab172f0c8b..3851c32d9abdbebea03f97edf6fcb383dd98f05b 100644 | 
| --- a/runtime/bin/file_android.cc | 
| +++ b/runtime/bin/file_android.cc | 
| @@ -17,6 +17,7 @@ | 
|  | 
| #include "bin/builtin.h" | 
| #include "bin/log.h" | 
| +#include "bin/signal_blocker.h" | 
|  | 
|  | 
| namespace dart { | 
| @@ -47,7 +48,7 @@ File::~File() { | 
|  | 
| void File::Close() { | 
| ASSERT(handle_->fd() >= 0); | 
| -  int err = TEMP_FAILURE_RETRY(close(handle_->fd())); | 
| +  int err = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(close(handle_->fd())); | 
| if (err != 0) { | 
| const int kBufferSize = 1024; | 
| char error_message[kBufferSize]; | 
| @@ -65,13 +66,15 @@ bool File::IsClosed() { | 
|  | 
| int64_t File::Read(void* buffer, int64_t num_bytes) { | 
| ASSERT(handle_->fd() >= 0); | 
| -  return TEMP_FAILURE_RETRY(read(handle_->fd(), buffer, num_bytes)); | 
| +  return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(read(handle_->fd(), buffer, | 
| +                                               num_bytes)); | 
| } | 
|  | 
|  | 
| int64_t File::Write(const void* buffer, int64_t num_bytes) { | 
| ASSERT(handle_->fd() >= 0); | 
| -  return TEMP_FAILURE_RETRY(write(handle_->fd(), buffer, num_bytes)); | 
| +  return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(write(handle_->fd(), buffer, | 
| +                                                num_bytes)); | 
| } | 
|  | 
|  | 
| @@ -89,20 +92,21 @@ bool File::SetPosition(off64_t position) { | 
|  | 
| bool File::Truncate(off64_t length) { | 
| ASSERT(handle_->fd() >= 0); | 
| -  return TEMP_FAILURE_RETRY(ftruncate(handle_->fd(), length) != -1); | 
| +  return TEMP_FAILURE_RETRY_BLOCK_SIGNALS( | 
| +      ftruncate(handle_->fd(), length) != -1); | 
| } | 
|  | 
|  | 
| bool File::Flush() { | 
| ASSERT(handle_->fd() >= 0); | 
| -  return TEMP_FAILURE_RETRY(fsync(handle_->fd()) != -1); | 
| +  return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(fsync(handle_->fd()) != -1); | 
| } | 
|  | 
|  | 
| off64_t File::Length() { | 
| ASSERT(handle_->fd() >= 0); | 
| struct stat st; | 
| -  if (TEMP_FAILURE_RETRY(fstat(handle_->fd(), &st)) == 0) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(fstat(handle_->fd(), &st)) == 0) { | 
| return st.st_size; | 
| } | 
| return -1; | 
| @@ -112,7 +116,7 @@ off64_t File::Length() { | 
| File* File::Open(const char* name, FileOpenMode mode) { | 
| // Report errors for non-regular files. | 
| struct stat st; | 
| -  if (TEMP_FAILURE_RETRY(stat(name, &st)) == 0) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(name, &st)) == 0) { | 
| if (!S_ISREG(st.st_mode)) { | 
| errno = (S_ISDIR(st.st_mode)) ? EISDIR : ENOENT; | 
| return NULL; | 
| @@ -126,7 +130,7 @@ File* File::Open(const char* name, FileOpenMode mode) { | 
| flags = flags | O_TRUNC; | 
| } | 
| flags |= O_CLOEXEC; | 
| -  int fd = TEMP_FAILURE_RETRY(open(name, flags, 0666)); | 
| +  int fd = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(open(name, flags, 0666)); | 
| if (fd < 0) { | 
| return NULL; | 
| } | 
| @@ -148,7 +152,7 @@ File* File::OpenStdio(int fd) { | 
|  | 
| bool File::Exists(const char* name) { | 
| struct stat st; | 
| -  if (TEMP_FAILURE_RETRY(stat(name, &st)) == 0) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(name, &st)) == 0) { | 
| return S_ISREG(st.st_mode); | 
| } else { | 
| return false; | 
| @@ -157,7 +161,9 @@ bool File::Exists(const char* name) { | 
|  | 
|  | 
| bool File::Create(const char* name) { | 
| -  int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CREAT | O_CLOEXEC, 0666)); | 
| +  int fd = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(open(name, | 
| +                                                 O_RDONLY | O_CREAT | O_CLOEXEC, | 
| +                                                 0666)); | 
| if (fd < 0) { | 
| return false; | 
| } | 
| @@ -166,7 +172,7 @@ bool File::Create(const char* name) { | 
|  | 
|  | 
| bool File::CreateLink(const char* name, const char* target) { | 
| -  int status = TEMP_FAILURE_RETRY(symlink(target, name)); | 
| +  int status = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(symlink(target, name)); | 
| return (status == 0); | 
| } | 
|  | 
| @@ -174,7 +180,7 @@ bool File::CreateLink(const char* name, const char* target) { | 
| bool File::Delete(const char* name) { | 
| File::Type type = File::GetType(name, true); | 
| if (type == kIsFile) { | 
| -    return TEMP_FAILURE_RETRY(unlink(name)) == 0; | 
| +    return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(unlink(name)) == 0; | 
| } else if (type == kIsDirectory) { | 
| errno = EISDIR; | 
| } else { | 
| @@ -187,7 +193,7 @@ bool File::Delete(const char* name) { | 
| bool File::DeleteLink(const char* name) { | 
| File::Type type = File::GetType(name, false); | 
| if (type == kIsLink) { | 
| -    return TEMP_FAILURE_RETRY(unlink(name)) == 0; | 
| +    return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(unlink(name)) == 0; | 
| } | 
| errno = EINVAL; | 
| return false; | 
| @@ -197,7 +203,7 @@ bool File::DeleteLink(const char* name) { | 
| bool File::Rename(const char* old_path, const char* new_path) { | 
| File::Type type = File::GetType(old_path, true); | 
| if (type == kIsFile) { | 
| -    return TEMP_FAILURE_RETRY(rename(old_path, new_path)) == 0; | 
| +    return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(rename(old_path, new_path)) == 0; | 
| } else if (type == kIsDirectory) { | 
| errno = EISDIR; | 
| } else { | 
| @@ -210,7 +216,7 @@ bool File::Rename(const char* old_path, const char* new_path) { | 
| bool File::RenameLink(const char* old_path, const char* new_path) { | 
| File::Type type = File::GetType(old_path, false); | 
| if (type == kIsLink) { | 
| -    return TEMP_FAILURE_RETRY(rename(old_path, new_path)) == 0; | 
| +    return TEMP_FAILURE_RETRY_BLOCK_SIGNALS(rename(old_path, new_path)) == 0; | 
| } else if (type == kIsDirectory) { | 
| errno = EISDIR; | 
| } else { | 
| @@ -224,24 +230,25 @@ bool File::Copy(const char* old_path, const char* new_path) { | 
| File::Type type = File::GetType(old_path, true); | 
| if (type == kIsFile) { | 
| struct stat st; | 
| -    if (TEMP_FAILURE_RETRY(stat(old_path, &st)) != 0) { | 
| +    if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(old_path, &st)) != 0) { | 
| return false; | 
| } | 
| -    int old_fd = TEMP_FAILURE_RETRY(open(old_path, O_RDONLY | O_CLOEXEC)); | 
| +    int old_fd = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(open(old_path, | 
| +                                                       O_RDONLY | O_CLOEXEC)); | 
| if (old_fd < 0) { | 
| return false; | 
| } | 
| -    int new_fd = TEMP_FAILURE_RETRY( | 
| +    int new_fd = TEMP_FAILURE_RETRY_BLOCK_SIGNALS( | 
| open(new_path, O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, st.st_mode)); | 
| if (new_fd < 0) { | 
| -      VOID_TEMP_FAILURE_RETRY(close(old_fd)); | 
| +      VOID_TEMP_FAILURE_RETRY_BLOCK_SIGNALS(close(old_fd)); | 
| return false; | 
| } | 
| off_t offset = 0; | 
| int result = 1; | 
| while (result > 0) { | 
| // Loop to ensure we copy everything, and not only up to 2GB. | 
| -      result = TEMP_FAILURE_RETRY( | 
| +      result = TEMP_FAILURE_RETRY_BLOCK_SIGNALS( | 
| sendfile(new_fd, old_fd, &offset, kMaxUint32)); | 
| } | 
| // From sendfile man pages: | 
| @@ -250,9 +257,10 @@ bool File::Copy(const char* old_path, const char* new_path) { | 
| if (result < 0 && (errno == EINVAL || errno == ENOSYS)) { | 
| const intptr_t kBufferSize = 8 * KB; | 
| uint8_t buffer[kBufferSize]; | 
| -      while ((result = TEMP_FAILURE_RETRY( | 
| +      while ((result = TEMP_FAILURE_RETRY_BLOCK_SIGNALS( | 
| read(old_fd, buffer, kBufferSize))) > 0) { | 
| -        int wrote = TEMP_FAILURE_RETRY(write(new_fd, buffer, result)); | 
| +        int wrote = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(write(new_fd, buffer, | 
| +                                                           result)); | 
| if (wrote != result) { | 
| result = -1; | 
| break; | 
| @@ -261,9 +269,9 @@ bool File::Copy(const char* old_path, const char* new_path) { | 
| } | 
| if (result < 0) { | 
| int e = errno; | 
| -      VOID_TEMP_FAILURE_RETRY(close(old_fd)); | 
| -      VOID_TEMP_FAILURE_RETRY(close(new_fd)); | 
| -      VOID_TEMP_FAILURE_RETRY(unlink(new_path)); | 
| +      VOID_TEMP_FAILURE_RETRY_BLOCK_SIGNALS(close(old_fd)); | 
| +      VOID_TEMP_FAILURE_RETRY_BLOCK_SIGNALS(close(new_fd)); | 
| +      VOID_TEMP_FAILURE_RETRY_BLOCK_SIGNALS(unlink(new_path)); | 
| errno = e; | 
| return false; | 
| } | 
| @@ -279,7 +287,7 @@ bool File::Copy(const char* old_path, const char* new_path) { | 
|  | 
| off64_t File::LengthFromPath(const char* name) { | 
| struct stat st; | 
| -  if (TEMP_FAILURE_RETRY(stat(name, &st)) == 0) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(name, &st)) == 0) { | 
| return st.st_size; | 
| } | 
| return -1; | 
| @@ -288,7 +296,7 @@ off64_t File::LengthFromPath(const char* name) { | 
|  | 
| void File::Stat(const char* name, int64_t* data) { | 
| struct stat st; | 
| -  if (TEMP_FAILURE_RETRY(stat(name, &st)) == 0) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(name, &st)) == 0) { | 
| if (S_ISREG(st.st_mode)) { | 
| data[kType] = kIsFile; | 
| } else if (S_ISDIR(st.st_mode)) { | 
| @@ -311,7 +319,7 @@ void File::Stat(const char* name, int64_t* data) { | 
|  | 
| time_t File::LastModified(const char* name) { | 
| struct stat st; | 
| -  if (TEMP_FAILURE_RETRY(stat(name, &st)) == 0) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(name, &st)) == 0) { | 
| return st.st_mtime; | 
| } | 
| return -1; | 
| @@ -393,9 +401,11 @@ File::Type File::GetType(const char* pathname, bool follow_links) { | 
| struct stat entry_info; | 
| int stat_success; | 
| if (follow_links) { | 
| -    stat_success = TEMP_FAILURE_RETRY(stat(pathname, &entry_info)); | 
| +    stat_success = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(stat(pathname, | 
| +                                                         &entry_info)); | 
| } else { | 
| -    stat_success = TEMP_FAILURE_RETRY(lstat(pathname, &entry_info)); | 
| +    stat_success = TEMP_FAILURE_RETRY_BLOCK_SIGNALS(lstat(pathname, | 
| +                                                          &entry_info)); | 
| } | 
| if (stat_success == -1) return File::kDoesNotExist; | 
| if (S_ISDIR(entry_info.st_mode)) return File::kIsDirectory; | 
| @@ -408,8 +418,8 @@ File::Type File::GetType(const char* pathname, bool follow_links) { | 
| File::Identical File::AreIdentical(const char* file_1, const char* file_2) { | 
| struct stat file_1_info; | 
| struct stat file_2_info; | 
| -  if (TEMP_FAILURE_RETRY(lstat(file_1, &file_1_info)) == -1 || | 
| -      TEMP_FAILURE_RETRY(lstat(file_2, &file_2_info)) == -1) { | 
| +  if (TEMP_FAILURE_RETRY_BLOCK_SIGNALS(lstat(file_1, &file_1_info)) == -1 || | 
| +      TEMP_FAILURE_RETRY_BLOCK_SIGNALS(lstat(file_2, &file_2_info)) == -1) { | 
| return File::kError; | 
| } | 
| return (file_1_info.st_ino == file_2_info.st_ino && | 
|  |