Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/src/google/protobuf/util/internal/utility.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 12 matching lines @@
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <google/protobuf/util/internal/utility.h>
 
-#include <algorithm>
-
 #include <google/protobuf/stubs/callback.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/wrappers.pb.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/util/internal/constants.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/map_util.h>
 #include <google/protobuf/stubs/mathlimits.h>
 
 namespace google {
 namespace protobuf {
 namespace util {
 namespace converter {
 
 namespace {
 const StringPiece SkipWhiteSpace(StringPiece str) {
   StringPiece::size_type i;
   for (i = 0; i < str.size() && isspace(str[i]); ++i) {
   }
   GOOGLE_DCHECK(i == str.size() || !isspace(str[i]));
-  return str.substr(i);
+  return StringPiece(str, i);
 }
 }  // namespace
 
 bool GetBoolOptionOrDefault(
     const google::protobuf::RepeatedPtrField<google::protobuf::Option>& options,
     const string& option_name, bool default_value) {
   const google::protobuf::Option* opt = FindOptionOrNull(options, option_name);
   if (opt == NULL) {
     return default_value;
   }
@@ skipping 55 matching lines @@
   return i.value();
 }
 
 string GetStringFromAny(const google::protobuf::Any& any) {
   google::protobuf::StringValue s;
   ParseFromAny(any.value(), &s);
   return s.value();
 }
 
 const StringPiece GetTypeWithoutUrl(StringPiece type_url) {
-  if (type_url.size() > kTypeUrlSize && type_url[kTypeUrlSize] == '/') {
-    return type_url.substr(kTypeUrlSize + 1);
-  } else {
-    size_t idx = type_url.rfind('/');
-    return type_url.substr(idx + 1);
-  }
+  size_t idx = type_url.rfind('/');
+  return type_url.substr(idx + 1);
 }
 
 const string GetFullTypeWithUrl(StringPiece simple_type) {
   return StrCat(kTypeServiceBaseUrl, "/", simple_type);
 }
 
 const google::protobuf::Option* FindOptionOrNull(
     const google::protobuf::RepeatedPtrField<google::protobuf::Option>& options,
     const string& option_name) {
   for (int i = 0; i < options.size(); ++i) {
@@ skipping 24 matching lines @@
     for (int i = 0; i < type->fields_size(); ++i) {
       const google::protobuf::Field& field = type->fields(i);
       if (field.json_name() == json_name) {
         return &field;
       }
     }
   }
   return NULL;
 }
 
-const google::protobuf::Field* FindFieldInTypeByNumberOrNull(
-    const google::protobuf::Type* type, int32 number) {
-  if (type != NULL) {
-    for (int i = 0; i < type->fields_size(); ++i) {
-      const google::protobuf::Field& field = type->fields(i);
-      if (field.number() == number) {
-        return &field;
-      }
-    }
-  }
-  return NULL;
-}
-
 const google::protobuf::EnumValue* FindEnumValueByNameOrNull(
     const google::protobuf::Enum* enum_type, StringPiece enum_name) {
   if (enum_type != NULL) {
     for (int i = 0; i < enum_type->enumvalue_size(); ++i) {
       const google::protobuf::EnumValue& enum_value = enum_type->enumvalue(i);
       if (enum_value.name() == enum_name) {
         return &enum_value;
       }
     }
   }
   return NULL;
 }
 
 const google::protobuf::EnumValue* FindEnumValueByNumberOrNull(
     const google::protobuf::Enum* enum_type, int32 value) {
   if (enum_type != NULL) {
     for (int i = 0; i < enum_type->enumvalue_size(); ++i) {
       const google::protobuf::EnumValue& enum_value = enum_type->enumvalue(i);
       if (enum_value.number() == value) {
         return &enum_value;
       }
     }
   }
   return NULL;
 }
 
-const google::protobuf::EnumValue* FindEnumValueByNameWithoutUnderscoreOrNull(
-    const google::protobuf::Enum* enum_type, StringPiece enum_name) {
-  if (enum_type != NULL) {
-    for (int i = 0; i < enum_type->enumvalue_size(); ++i) {
-      const google::protobuf::EnumValue& enum_value = enum_type->enumvalue(i);
-      string enum_name_without_underscore = enum_value.name();
-
-      // Remove underscore from the name.
-      enum_name_without_underscore.erase(
-          std::remove(enum_name_without_underscore.begin(),
-                      enum_name_without_underscore.end(), '_'),
-          enum_name_without_underscore.end());
-      // Make the name uppercase.
-      for (string::iterator it = enum_name_without_underscore.begin();
-           it != enum_name_without_underscore.end(); ++it) {
-        *it = ascii_toupper(*it);
-      }
-
-      if (enum_name_without_underscore == enum_name) {
-        return &enum_value;
-      }
-    }
-  }
-  return NULL;
-}
-
 string ToCamelCase(const StringPiece input) {
   bool capitalize_next = false;
   bool was_cap = true;
   bool is_cap = false;
   bool first_word = true;
   string result;
   result.reserve(input.size());
 
   for (size_t i = 0; i < input.size(); ++i, was_cap = is_cap) {
     is_cap = ascii_isupper(input[i]);
@@ skipping 59 matching lines @@
       was_not_cap = false;
     } else {
       result.push_back(input[i]);
       was_not_underscore = input[i] != '_';
       was_not_cap = true;
     }
   }
   return result;
 }
 
-std::set<string>* well_known_types_ = NULL;
+set<string>* well_known_types_ = NULL;
 GOOGLE_PROTOBUF_DECLARE_ONCE(well_known_types_init_);
 const char* well_known_types_name_array_[] = {
     "google.protobuf.Timestamp",   "google.protobuf.Duration",
     "google.protobuf.DoubleValue", "google.protobuf.FloatValue",
     "google.protobuf.Int64Value",  "google.protobuf.UInt64Value",
     "google.protobuf.Int32Value",  "google.protobuf.UInt32Value",
     "google.protobuf.BoolValue",   "google.protobuf.StringValue",
     "google.protobuf.BytesValue",  "google.protobuf.FieldMask"};
 
 void DeleteWellKnownTypes() { delete well_known_types_; }
 
 void InitWellKnownTypes() {
-  well_known_types_ = new std::set<string>;
+  well_known_types_ = new set<string>;
   for (int i = 0; i < GOOGLE_ARRAYSIZE(well_known_types_name_array_); ++i) {
     well_known_types_->insert(well_known_types_name_array_[i]);
   }
   google::protobuf::internal::OnShutdown(&DeleteWellKnownTypes);
 }
 
 bool IsWellKnownType(const string& type_name) {
   InitWellKnownTypes();
   return ContainsKey(*well_known_types_, type_name);
 }
 
 bool IsValidBoolString(const string& bool_string) {
   return bool_string == "true" || bool_string == "false" ||
          bool_string == "1" || bool_string == "0";
 }
 
 bool IsMap(const google::protobuf::Field& field,
            const google::protobuf::Type& type) {
-  return (
-      field.cardinality() ==
-          google::protobuf::Field_Cardinality_CARDINALITY_REPEATED &&
-      (GetBoolOptionOrDefault(
-           type.options(), "google.protobuf.MessageOptions.map_entry", false) ||
-       GetBoolOptionOrDefault(type.options(), "proto2.MessageOptions.map_entry",
-                              false)));
+  return (field.cardinality() ==
+              google::protobuf::Field_Cardinality_CARDINALITY_REPEATED &&
+          GetBoolOptionOrDefault(type.options(),
+                                 "google.protobuf.MessageOptions.map_entry", false));
 }
 
 bool IsMessageSetWireFormat(const google::protobuf::Type& type) {
-  return (
-      GetBoolOptionOrDefault(
-          type.options(),
-          "google.protobuf.MessageOptions.message_set_wire_format", false) ||
-      GetBoolOptionOrDefault(type.options(),
-                             "proto2.MessageOptions.message_set_wire_format",
-                             false));
+  return GetBoolOptionOrDefault(
+      type.options(), "google.protobuf.MessageOptions.message_set_wire_format", false);
 }
 
 string DoubleAsString(double value) {
   if (MathLimits<double>::IsPosInf(value)) return "Infinity";
   if (MathLimits<double>::IsNegInf(value)) return "-Infinity";
   if (MathLimits<double>::IsNaN(value)) return "NaN";
 
   return SimpleDtoa(value);
 }
 
@@ skipping 19 matching lines @@
   }
 
   *value = static_cast<float>(double_value);
   return true;
 }
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google
-