Fix else-after-return in base

$ ninja -C out/Release base
$ tools/clang/scripts/generate_compdb.py -p out/Release \
  > out/Release/compile_commands.json
$ cd out/Release
$ ~/dev/llvm/llvm/tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py \
  -p . -clang-tidy-binary ~/dev/llvm/build/bin/clang-tidy \
  -clang-apply-replacements-binary \
  ~/dev/llvm/build/bin/clang-apply-replacements
  -checks=readability-else-after-return -fix ~/dev/chromium_official/src/base/
$ cd ../..
$ git checkout base/third_party
$ git cl format

R=thestig

Change-Id: Ifc44900f372ed4027027ba50f7a7de22d0e2f0ec
Reviewed-on: https://chromium-review.googlesource.com/1214691
Commit-Queue: Thomas Anderson <thomasanderson@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#590385}

base/allocator/allocator_shim_unittest.cc

@@ -107,9 +107,8 @@ class AllocatorShimTest : public testing::Test {
         if (!instance_->did_fail_realloc_0xfeed_once->Get()) {
           instance_->did_fail_realloc_0xfeed_once->Set(true);
           return nullptr;
-        } else {
-          return address;
         }
+        return address;
       }
 
       if (size < kMaxSizeTracked)

base/allocator/partition_allocator/partition_alloc.cc

@@ -276,8 +276,7 @@ void* PartitionReallocGenericFlags(PartitionRootGeneric* root,
   if (new_size > kGenericMaxDirectMapped) {
     if (flags & PartitionAllocReturnNull)
       return nullptr;
-    else
-      internal::PartitionExcessiveAllocationSize();
+    internal::PartitionExcessiveAllocationSize();
   }
 
   internal::PartitionPage* page = internal::PartitionPage::FromPointer(
@@ -320,8 +319,7 @@ void* PartitionReallocGenericFlags(PartitionRootGeneric* root,
   if (!ret) {
     if (flags & PartitionAllocReturnNull)
       return nullptr;
-    else
-      internal::PartitionExcessiveAllocationSize();
+    internal::PartitionExcessiveAllocationSize();
   }
 
   size_t copy_size = actual_old_size;

base/allocator/tcmalloc_unittest.cc

@@ -68,9 +68,8 @@ static int NextSize(int size) {
 
     CHECK_EQ(size, power);
     return power + 1;
-  } else {
-    return -1;
   }
+  return -1;
 }
 
 static void TestCalloc(size_t n, size_t s, bool ok) {

base/i18n/rtl.cc

@@ -71,15 +71,16 @@ base::i18n::TextDirection GetCharacterDirection(UChar32 character) {
   // Now that we have the character, we use ICU in order to query for the
   // appropriate Unicode BiDi character type.
   int32_t property = u_getIntPropertyValue(character, UCHAR_BIDI_CLASS);
-  if ((property == U_RIGHT_TO_LEFT) ||
-      (property == U_RIGHT_TO_LEFT_ARABIC) ||
-      (property == U_RIGHT_TO_LEFT_EMBEDDING) ||
-      (property == U_RIGHT_TO_LEFT_OVERRIDE)) {
-    return base::i18n::RIGHT_TO_LEFT;
-  } else if ((property == U_LEFT_TO_RIGHT) ||
-             (property == U_LEFT_TO_RIGHT_EMBEDDING) ||
-             (property == U_LEFT_TO_RIGHT_OVERRIDE)) {
-    return base::i18n::LEFT_TO_RIGHT;
+  switch (property) {
+    case U_RIGHT_TO_LEFT:
+    case U_RIGHT_TO_LEFT_ARABIC:
+    case U_RIGHT_TO_LEFT_EMBEDDING:
+    case U_RIGHT_TO_LEFT_OVERRIDE:
+      return base::i18n::RIGHT_TO_LEFT;
+    case U_LEFT_TO_RIGHT:
+    case U_LEFT_TO_RIGHT_EMBEDDING:
+    case U_LEFT_TO_RIGHT_OVERRIDE:
+      return base::i18n::LEFT_TO_RIGHT;
   }
   return base::i18n::UNKNOWN_DIRECTION;
 }

base/i18n/string_search.cc

@@ -48,15 +48,13 @@ bool FixedPatternStringSearchIgnoringCaseAndAccents::Search(
   // substring search will give the correct return value.
   if (!U_SUCCESS(status)) {
     size_t index = in_this.find(find_this_);
-    if (index == string16::npos) {
+    if (index == string16::npos)
       return false;
-    } else {
-      if (match_index)
-        *match_index = index;
-      if (match_length)
-        *match_length = find_this_.size();
-      return true;
-    }
+    if (match_index)
+      *match_index = index;
+    if (match_length)
+      *match_length = find_this_.size();
+    return true;
   }
 
   int32_t index = usearch_first(search_, &status);

base/i18n/time_formatting.cc

@@ -123,9 +123,8 @@ string16 TimeFormatTimeOfDayWithHourClockType(const Time& time,
 
   if (ampm == kKeepAmPm) {
     return TimeFormat(&formatter, time);
-  } else {
-    return TimeFormatWithoutAmPm(&formatter, time);
   }
+  return TimeFormatWithoutAmPm(&formatter, time);
 }
 
 string16 TimeFormatShortDate(const Time& time) {
@@ -291,11 +290,7 @@ HourClockType GetHourClockType() {
   //
   // See http://userguide.icu-project.org/formatparse/datetime for details
   // about the date/time format syntax.
-  if (pattern_unicode.indexOf('a') == -1) {
-    return k24HourClock;
-  } else {
-    return k12HourClock;
-  }
+  return pattern_unicode.indexOf('a') == -1 ? k24HourClock : k12HourClock;
 }
 
 }  // namespace base

base/json/json_file_value_serializer.cc

@@ -69,10 +69,8 @@ int JSONFileValueDeserializer::ReadFileToString(std::string* json_string) {
       return JSON_ACCESS_DENIED;
     }
 #endif
-    if (!base::PathExists(json_file_path_))
-      return JSON_NO_SUCH_FILE;
-    else
-      return JSON_CANNOT_READ_FILE;
+    return base::PathExists(json_file_path_) ? JSON_CANNOT_READ_FILE
+                                             : JSON_NO_SUCH_FILE;
   }
 
   last_read_size_ = json_string->size();

base/json/json_parser.cc

@@ -471,7 +471,8 @@ bool JSONParser::ConsumeStringRaw(StringBuilder* out) {
       ConsumeChar();
       *out = std::move(string);
       return true;
-    } else if (next_char != '\\') {
+    }
+    if (next_char != '\\') {
       // If this character is not an escape sequence...
       ConsumeChar();
       string.Append(next_char);
@@ -714,16 +715,14 @@ bool JSONParser::ReadInt(bool allow_leading_zeros) {
 }
 
 Optional<Value> JSONParser::ConsumeLiteral() {
-  if (ConsumeIfMatch("true")) {
+  if (ConsumeIfMatch("true"))
     return Value(true);
-  } else if (ConsumeIfMatch("false")) {
+  if (ConsumeIfMatch("false"))
     return Value(false);
-  } else if (ConsumeIfMatch("null")) {
+  if (ConsumeIfMatch("null"))
     return Value(Value::Type::NONE);
-  } else {
-    ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
-    return nullopt;
-  }
+  ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
+  return nullopt;
 }
 
 bool JSONParser::ConsumeIfMatch(StringPiece match) {

base/json/json_value_converter_unittest.cc

@@ -34,7 +34,8 @@ struct SimpleMessage {
     if (value == "foo") {
       *field = FOO;
       return true;
-    } else if (value == "bar") {
+    }
+    if (value == "bar") {
       *field = BAR;
       return true;
     }

base/message_loop/message_loop_unittest.cc

@@ -169,8 +169,7 @@ std::ostream& operator <<(std::ostream& os, TaskType type) {
 std::ostream& operator <<(std::ostream& os, const TaskItem& item) {
   if (item.start)
     return os << item.type << " " << item.cookie << " starts";
-  else
-    return os << item.type << " " << item.cookie << " ends";
+  return os << item.type << " " << item.cookie << " ends";
 }
 
 class TaskList {

base/metrics/persistent_memory_allocator.cc

@@ -817,17 +817,15 @@ void PersistentMemoryAllocator::MakeIterable(Reference ref) {
                                                      std::memory_order_release,
                                                      std::memory_order_relaxed);
       return;
-    } else {
-      // In the unlikely case that a thread crashed or was killed between the
-      // update of "next" and the update of "tailptr", it is necessary to
-      // perform the operation that would have been done. There's no explicit
-      // check for crash/kill which means that this operation may also happen
-      // even when the other thread is in perfect working order which is what
-      // necessitates the CompareAndSwap above.
-      shared_meta()->tailptr.compare_exchange_strong(tail, next,
-                                                     std::memory_order_acq_rel,
-                                                     std::memory_order_acquire);
     }
+    // In the unlikely case that a thread crashed or was killed between the
+    // update of "next" and the update of "tailptr", it is necessary to
+    // perform the operation that would have been done. There's no explicit
+    // check for crash/kill which means that this operation may also happen
+    // even when the other thread is in perfect working order which is what
+    // necessitates the CompareAndSwap above.
+    shared_meta()->tailptr.compare_exchange_strong(
+        tail, next, std::memory_order_acq_rel, std::memory_order_acquire);
   }
 }
 

base/process/kill_posix.cc

@@ -36,7 +36,8 @@ TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
     DPLOG(ERROR) << "waitpid(" << handle << ")";
     *exit_code = 0;
     return TERMINATION_STATUS_NORMAL_TERMINATION;
-  } else if (result == 0) {
+  }
+  if (result == 0) {
     // the child hasn't exited yet.
     *exit_code = 0;
     return TERMINATION_STATUS_STILL_RUNNING;

base/process/launch_posix.cc

@@ -376,7 +376,8 @@ Process LaunchProcess(const std::vector<std::string>& argv,
   if (pid < 0) {
     DPLOG(ERROR) << "fork";
     return Process();
-  } else if (pid == 0) {
+  }
+  if (pid == 0) {
     // Child process
 
     // DANGER: no calls to malloc or locks are allowed from now on:

base/sha1.cc

@@ -66,15 +66,13 @@ class SecureHashAlgorithm {
 };
 
 static inline uint32_t f(uint32_t t, uint32_t B, uint32_t C, uint32_t D) {
-  if (t < 20) {
+  if (t < 20)
     return (B & C) | ((~B) & D);
-  } else if (t < 40) {
+  if (t < 40)
     return B ^ C ^ D;
-  } else if (t < 60) {
+  if (t < 60)
     return (B & C) | (B & D) | (C & D);
-  } else {
-    return B ^ C ^ D;
-  }
+  return B ^ C ^ D;
 }
 
 static inline uint32_t S(uint32_t n, uint32_t X) {
@@ -82,15 +80,13 @@ static inline uint32_t S(uint32_t n, uint32_t X) {
 }
 
 static inline uint32_t K(uint32_t t) {
-  if (t < 20) {
+  if (t < 20)
     return 0x5a827999;
-  } else if (t < 40) {
+  if (t < 40)
     return 0x6ed9eba1;
-  } else if (t < 60) {
+  if (t < 60)
     return 0x8f1bbcdc;
-  } else {
-    return 0xca62c1d6;
-  }
+  return 0xca62c1d6;
 }
 
 const int SecureHashAlgorithm::kDigestSizeBytes = 20;

base/strings/safe_sprintf.cc

@@ -7,6 +7,7 @@
 #include <errno.h>
 #include <string.h>
 
+#include <algorithm>
 #include <limits>
 
 #include "base/macros.h"
@@ -236,10 +237,9 @@ class Buffer {
     if (count_ > kSSizeMax - 1 - inc) {
       count_ = kSSizeMax - 1;
       return false;
-    } else {
-      count_ += inc;
-      return true;
     }
+    count_ += inc;
+    return true;
   }
 
   // Convenience method for the common case of incrementing |count_| by one.
@@ -433,11 +433,9 @@ ssize_t SafeSNPrintf(char* buf, size_t sz, const char* fmt, const Arg* args,
   // never overflows kSSizeMax. Not only does that use up most or all of the
   // address space, it also would result in a return code that cannot be
   // represented.
-  if (static_cast<ssize_t>(sz) < 1) {
+  if (static_cast<ssize_t>(sz) < 1)
     return -1;
-  } else if (sz > kSSizeMax) {
-    sz = kSSizeMax;
-  }
+  sz = std::min(sz, kSSizeMax);
 
   // Iterate over format string and interpret '%' arguments as they are
   // encountered.
@@ -659,11 +657,9 @@ ssize_t SafeSNPrintf(char* buf, size_t sz, const char* fmt) {
   // never overflows kSSizeMax. Not only does that use up most or all of the
   // address space, it also would result in a return code that cannot be
   // represented.
-  if (static_cast<ssize_t>(sz) < 1) {
+  if (static_cast<ssize_t>(sz) < 1)
     return -1;
-  } else if (sz > kSSizeMax) {
-    sz = kSSizeMax;
-  }
+  sz = std::min(sz, kSSizeMax);
 
   Buffer buffer(buf, sz);
 

base/test/trace_event_analyzer.cc

@@ -467,13 +467,11 @@ bool Query::GetAsString(const TraceEvent& event, std::string* str) const {
 
 const TraceEvent* Query::SelectTargetEvent(const TraceEvent* event,
                                            TraceEventMember member) {
-  if (member >= OTHER_FIRST_MEMBER && member <= OTHER_LAST_MEMBER) {
+  if (member >= OTHER_FIRST_MEMBER && member <= OTHER_LAST_MEMBER)
     return event->other_event;
-  } else if (member >= PREV_FIRST_MEMBER && member <= PREV_LAST_MEMBER) {
+  if (member >= PREV_FIRST_MEMBER && member <= PREV_LAST_MEMBER)
     return event->prev_event;
-  } else {
-    return event;
-  }
+  return event;
 }
 
 bool Query::GetMemberValueAsDouble(const TraceEvent& event,

base/time/time_exploded_posix.cc

@@ -106,10 +106,7 @@ typedef time_t SysTime;
 
 SysTime SysTimeFromTimeStruct(struct tm* timestruct, bool is_local) {
   base::AutoLock locked(*GetSysTimeToTimeStructLock());
-  if (is_local)
-    return mktime(timestruct);
-  else
-    return timegm(timestruct);
+  return is_local ? mktime(timestruct) : timegm(timestruct);
 }
 
 void SysTimeToTimeStruct(SysTime t, struct tm* timestruct, bool is_local) {

base/time/time_now_posix.cc

@@ -33,12 +33,11 @@ int64_t ConvertTimespecToMicros(const struct timespec& ts) {
     result *= base::Time::kMicrosecondsPerSecond;
     result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
     return result;
-  } else {
-    base::CheckedNumeric<int64_t> result(ts.tv_sec);
-    result *= base::Time::kMicrosecondsPerSecond;
-    result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
-    return result.ValueOrDie();
   }
+  base::CheckedNumeric<int64_t> result(ts.tv_sec);
+  result *= base::Time::kMicrosecondsPerSecond;
+  result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
+  return result.ValueOrDie();
 }
 
 // Helper function to get results from clock_gettime() and convert to a

base/values.cc

@@ -486,7 +486,8 @@ bool Value::GetAsDouble(double* out_value) const {
   if (out_value && is_double()) {
     *out_value = double_value_;
     return true;
-  } else if (out_value && is_int()) {
+  }
+  if (out_value && is_int()) {
     // Allow promotion from int to double.
     *out_value = int_value_;
     return true;