Fix "unreachable code" warnings (MSVC warning 4702) in base/.

base/test/trace_event_analyzer.cc

 // Copyright (c) 2012 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 "base/test/trace_event_analyzer.h"
 
 #include <algorithm>
 #include <math.h>
 #include <set>
 
@@ skipping 263 matching lines @@
   // It's a logical operator.
   switch (operator_) {
     case OP_AND:
       return left().Evaluate(event) && right().Evaluate(event);
     case OP_OR:
       return left().Evaluate(event) || right().Evaluate(event);
     case OP_NOT:
       return !left().Evaluate(event);
     default:
       NOTREACHED();
+      return false;
   }
-
-  NOTREACHED();
-  return false;
 }
 
 bool Query::CompareAsDouble(const TraceEvent& event, bool* result) const {
   double lhs, rhs;
   if (!left().GetAsDouble(event, &lhs) || !right().GetAsDouble(event, &rhs))
     return false;
   switch (operator_) {
     case OP_EQ:
       *result = (lhs == rhs);
       return true;
     case OP_NE:
       *result = (lhs != rhs);
       return true;
     case OP_LT:
       *result = (lhs < rhs);
       return true;
     case OP_LE:
       *result = (lhs <= rhs);
       return true;
     case OP_GT:
       *result = (lhs > rhs);
       return true;
     case OP_GE:
       *result = (lhs >= rhs);
       return true;
     default:
       NOTREACHED();
       return false;
   }
-  return true;
 }
 
 bool Query::CompareAsString(const TraceEvent& event, bool* result) const {
   std::string lhs, rhs;
   if (!left().GetAsString(event, &lhs) || !right().GetAsString(event, &rhs))
     return false;
   switch (operator_) {
     case OP_EQ:
       if (right().is_pattern_)
         *result = MatchPattern(lhs, rhs);
@@ skipping 19 matching lines @@
     case OP_GT:
       *result = (lhs > rhs);
       return true;
     case OP_GE:
       *result = (lhs >= rhs);
       return true;
     default:
       NOTREACHED();
       return false;
   }
-  return true;
 }
 
 bool Query::EvaluateArithmeticOperator(const TraceEvent& event,
                                        double* num) const {
   DCHECK_EQ(QUERY_ARITHMETIC_OPERATOR, type_);
   DCHECK(left_.get());
   DCHECK(right_.get() || is_unary_operator());
 
   double lhs = 0, rhs = 0;
   if (!left().GetAsDouble(event, &lhs))
@@ skipping 528 matching lines @@
     }
   }
   return false;
 }
 
 bool FindLastOf(const TraceEventVector& events,
                 const Query& query,
                 size_t position,
                 size_t* return_index) {
   DCHECK(return_index);
-  if (events.empty())
-    return false;
-  position = (position < events.size()) ? position : events.size() - 1;
-  for (;;) {
-    if (query.Evaluate(*events[position])) {
-      *return_index = position;
+  for (size_t i = std::min(position + 1, events.size()); i != 0; --i) {
+    if (query.Evaluate(*events[i - 1])) {
+      *return_index = i - 1;
       return true;
     }
-    if (position == 0)
-      return false;
-    --position;
   }
   return false;
 }
 
 bool FindClosest(const TraceEventVector& events,
                  const Query& query,
                  size_t position,
                  size_t* return_closest,
                  size_t* return_second_closest) {
   DCHECK(return_closest);
@@ skipping 37 matching lines @@
   end_position = (end_position < events.size()) ? end_position : events.size();
   size_t count = 0u;
   for (size_t i = begin_position; i < end_position; ++i) {
     if (query.Evaluate(*events.at(i)))
       ++count;
   }
   return count;
 }
 
 }  // namespace trace_analyzer