enum class fixups - testing non-zero

services/files/file_impl.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "services/files/file_impl.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 53 matching lines @@
                     Whence whence,
                     const ReadCallback& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED, Array<uint8_t>());
     return;
   }
   if (num_bytes_to_read > kMaxReadSize) {
     callback.Run(ERROR_OUT_OF_RANGE, Array<uint8_t>());
     return;
   }
-  if (Error error = IsOffsetValid(offset)) {
+
+  Error error = IsOffsetValid(offset);
+  if (error != ERROR_OK) {
     callback.Run(error, Array<uint8_t>());
     return;
   }
-  if (Error error = IsWhenceValid(whence)) {
+
+  error = IsWhenceValid(whence);
+  if (error != ERROR_OK) {
     callback.Run(error, Array<uint8_t>());
     return;
   }
 
   if (offset != 0 || whence != WHENCE_FROM_CURRENT) {
     // TODO(vtl): Use |pread()| below in the |WHENCE_FROM_START| case. This
     // implementation is obviously not atomic. (If someone seeks simultaneously,
     // we'll end up writing somewhere else. Or, well, we would if we were
     // multithreaded.) Maybe we should do an |ftell()| and always use |pread()|.
     // TODO(vtl): Possibly, at least sometimes we should not change the file
@@ skipping 29 matching lines @@
     callback.Run(ERROR_CLOSED, 0);
     return;
   }
   // Who knows what |write()| would return if the size is that big (and it
   // actually wrote that much).
   if (bytes_to_write.size() >
       static_cast<size_t>(std::numeric_limits<ssize_t>::max())) {
     callback.Run(ERROR_OUT_OF_RANGE, 0);
     return;
   }
-  if (Error error = IsOffsetValid(offset)) {
+
+  Error error = IsOffsetValid(offset);
+  if (error != ERROR_OK) {
     callback.Run(error, 0);
     return;
   }
-  if (Error error = IsWhenceValid(whence)) {
+
+  error = IsWhenceValid(whence);
+  if (error != ERROR_OK) {
     callback.Run(error, 0);
     return;
   }
 
   if (offset != 0 || whence != WHENCE_FROM_CURRENT) {
     // TODO(vtl): Use |pwrite()| below in the |WHENCE_FROM_START| case. This
     // implementation is obviously not atomic. (If someone seeks simultaneously,
     // we'll end up writing somewhere else. Or, well, we would if we were
     // multithreaded.) Maybe we should do an |ftell()| and always use
     // |pwrite()|.
@@ skipping 22 matching lines @@
 
 void FileImpl::ReadToStream(ScopedDataPipeProducerHandle source,
                             int64_t offset,
                             Whence whence,
                             int64_t num_bytes_to_read,
                             const ReadToStreamCallback& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED);
     return;
   }
-  if (Error error = IsOffsetValid(offset)) {
+
+  Error error = IsOffsetValid(offset);
+  if (error != ERROR_OK) {
     callback.Run(error);
     return;
   }
-  if (Error error = IsWhenceValid(whence)) {
+
+  error = IsWhenceValid(whence);
+  if (error != ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   // TODO(vtl): FIXME soon
   NOTIMPLEMENTED();
   callback.Run(ERROR_UNIMPLEMENTED);
 }
 
 void FileImpl::WriteFromStream(ScopedDataPipeConsumerHandle sink,
                                int64_t offset,
                                Whence whence,
                                const WriteFromStreamCallback& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED);
     return;
   }
-  if (Error error = IsOffsetValid(offset)) {
+
+  Error error = IsOffsetValid(offset);
+  if (error != ERROR_OK) {
     callback.Run(error);
     return;
   }
-  if (Error error = IsWhenceValid(whence)) {
+
+  error = IsWhenceValid(whence);
+  if (error != ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   // TODO(vtl): FIXME soon
   NOTIMPLEMENTED();
   callback.Run(ERROR_UNIMPLEMENTED);
 }
 
 void FileImpl::Tell(const TellCallback& callback) {
   Seek(0, WHENCE_FROM_CURRENT, callback);
 }
 
 void FileImpl::Seek(int64_t offset,
                     Whence whence,
                     const SeekCallback& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED, 0);
     return;
   }
-  if (Error error = IsOffsetValid(offset)) {
+
+  Error error = IsOffsetValid(offset);
+  if (error != ERROR_OK) {
     callback.Run(error, 0);
     return;
   }
-  if (Error error = IsWhenceValid(whence)) {
+
+  error = IsWhenceValid(whence);
+  if (error != ERROR_OK) {
     callback.Run(error, 0);
     return;
   }
 
   off_t position = lseek(file_fd_.get(), static_cast<off_t>(offset),
                          WhenceToStandardWhence(whence));
   if (position < 0) {
     callback.Run(ErrnoToError(errno), 0);
     return;
   }
@@ skipping 11 matching lines @@
 
 void FileImpl::Truncate(int64_t size, const TruncateCallback& callback) {
   if (!file_fd_.is_valid()) {
     callback.Run(ERROR_CLOSED);
     return;
   }
   if (size < 0) {
     callback.Run(ERROR_INVALID_ARGUMENT);
     return;
   }
-  if (Error error = IsOffsetValid(size)) {
+
+  Error error = IsOffsetValid(size);
+  if (error != ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   if (ftruncate(file_fd_.get(), static_cast<off_t>(size)) != 0) {
     callback.Run(ErrnoToError(errno));
     return;
   }
 
   callback.Run(ERROR_OK);
@@ skipping 57 matching lines @@
     return;
   }
 
   // TODO(vtl): The "correct" error code should be one that can be translated to
   // ENOTTY!
   callback.Run(ERROR_UNAVAILABLE, Array<uint32_t>());
 }
 
 }  // namespace files
 }  // namespace mojo