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

third_party/protobuf/src/google/protobuf/util/type_resolver_util.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 36 matching lines @@
 using google::protobuf::Enum;
 using google::protobuf::EnumValue;
 using google::protobuf::Field;
 using google::protobuf::Option;
 using google::protobuf::Type;
 
 using util::Status;
 using util::error::INVALID_ARGUMENT;
 using util::error::NOT_FOUND;
 
+bool SplitTypeUrl(const string& type_url, string* url_prefix,
+                  string* message_name) {
+  size_t pos = type_url.find_last_of("/");
+  if (pos == string::npos) {
+    return false;
+  }
+  *url_prefix = type_url.substr(0, pos);
+  *message_name = type_url.substr(pos + 1);
+  return true;
+}
+
 class DescriptorPoolTypeResolver : public TypeResolver {
  public:
   DescriptorPoolTypeResolver(const string& url_prefix,
                              const DescriptorPool* pool)
       : url_prefix_(url_prefix), pool_(pool) {}
 
   Status ResolveMessageType(const string& type_url, Type* type) {
-    string type_name;
-    Status status = ParseTypeUrl(type_url, &type_name);
-    if (!status.ok()) {
-      return status;
+    string url_prefix, message_name;
+    if (!SplitTypeUrl(type_url, &url_prefix, &message_name) ||
+        url_prefix != url_prefix_) {
+      return Status(INVALID_ARGUMENT,
+                    StrCat("Invalid type URL, type URLs must be of the form '",
+                           url_prefix_, "/<typename>', got: ", type_url));
     }
-
-    const Descriptor* descriptor = pool_->FindMessageTypeByName(type_name);
+    if (url_prefix != url_prefix_) {
+      return Status(INVALID_ARGUMENT,
+                    "Cannot resolve types from URL: " + url_prefix);
+    }
+    const Descriptor* descriptor = pool_->FindMessageTypeByName(message_name);
     if (descriptor == NULL) {
-      return Status(NOT_FOUND, "Invalid type URL, unknown type: " + type_name);
+      return Status(NOT_FOUND,
+                    "Invalid type URL, unknown type: " + message_name);
     }
     ConvertDescriptor(descriptor, type);
     return Status();
   }
 
   Status ResolveEnumType(const string& type_url, Enum* enum_type) {
-    string type_name;
-    Status status = ParseTypeUrl(type_url, &type_name);
-    if (!status.ok()) {
-      return status;
+    string url_prefix, type_name;
+    if (!SplitTypeUrl(type_url, &url_prefix, &type_name) ||
+        url_prefix != url_prefix_) {
+      return Status(INVALID_ARGUMENT,
+                    StrCat("Invalid type URL, type URLs must be of the form '",
+                           url_prefix_, "/<typename>', got: ", type_url));
     }
-
+    if (url_prefix != url_prefix_) {
+      return Status(INVALID_ARGUMENT,
+                    "Cannot resolve types from URL: " + url_prefix);
+    }
     const EnumDescriptor* descriptor = pool_->FindEnumTypeByName(type_name);
     if (descriptor == NULL) {
       return Status(NOT_FOUND, "Invalid type URL, unknown type: " + type_name);
     }
     ConvertEnumDescriptor(descriptor, enum_type);
     return Status();
   }
 
  private:
   void ConvertDescriptor(const Descriptor* descriptor, Type* type) {
@@ skipping 79 matching lines @@
   }
 
   string GetTypeUrl(const Descriptor* descriptor) {
     return url_prefix_ + "/" + descriptor->full_name();
   }
 
   string GetTypeUrl(const EnumDescriptor* descriptor) {
     return url_prefix_ + "/" + descriptor->full_name();
   }
 
-  Status ParseTypeUrl(const string& type_url, string* type_name) {
-    if (type_url.substr(0, url_prefix_.size() + 1) != url_prefix_ + "/") {
-      return Status(INVALID_ARGUMENT,
-                    StrCat("Invalid type URL, type URLs must be of the form '",
-                           url_prefix_, "/<typename>', got: ", type_url));
-    }
-    *type_name = type_url.substr(url_prefix_.size() + 1);
-    return Status();
-  }
-
   string DefaultValueAsString(const FieldDescriptor* descriptor) {
     switch (descriptor->cpp_type()) {
       case FieldDescriptor::CPPTYPE_INT32:
         return SimpleItoa(descriptor->default_value_int32());
         break;
       case FieldDescriptor::CPPTYPE_INT64:
         return SimpleItoa(descriptor->default_value_int64());
         break;
       case FieldDescriptor::CPPTYPE_UINT32:
         return SimpleItoa(descriptor->default_value_uint32());
@@ skipping 34 matching lines @@
 }  // namespace
 
 TypeResolver* NewTypeResolverForDescriptorPool(const string& url_prefix,
                                                const DescriptorPool* pool) {
   return new DescriptorPoolTypeResolver(url_prefix, pool);
 }
 
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google