Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/compiler/plugin.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 44 matching lines @@
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 
 class GeneratorResponseContext : public GeneratorContext {
  public:
-  GeneratorResponseContext(
-      const Version& compiler_version,
-      CodeGeneratorResponse* response,
-      const std::vector<const FileDescriptor*>& parsed_files)
-      : compiler_version_(compiler_version),
-        response_(response),
+  GeneratorResponseContext(CodeGeneratorResponse* response,
+                           const vector<const FileDescriptor*>& parsed_files)
+      : response_(response),
         parsed_files_(parsed_files) {}
   virtual ~GeneratorResponseContext() {}
 
   // implements GeneratorContext --------------------------------------
 
   virtual io::ZeroCopyOutputStream* Open(const string& filename) {
     CodeGeneratorResponse::File* file = response_->add_file();
     file->set_name(filename);
     return new io::StringOutputStream(file->mutable_content());
   }
 
   virtual io::ZeroCopyOutputStream* OpenForInsert(
       const string& filename, const string& insertion_point) {
     CodeGeneratorResponse::File* file = response_->add_file();
     file->set_name(filename);
     file->set_insertion_point(insertion_point);
     return new io::StringOutputStream(file->mutable_content());
   }
 
-  void ListParsedFiles(std::vector<const FileDescriptor*>* output) {
+  void ListParsedFiles(vector<const FileDescriptor*>* output) {
     *output = parsed_files_;
   }
 
-  void GetCompilerVersion(Version* version) const {
-    *version = compiler_version_;
-  }
-
  private:
-  Version compiler_version_;
   CodeGeneratorResponse* response_;
-  const std::vector<const FileDescriptor*>& parsed_files_;
+  const vector<const FileDescriptor*>& parsed_files_;
 };
 
 bool GenerateCode(const CodeGeneratorRequest& request,
     const CodeGenerator& generator, CodeGeneratorResponse* response,
     string* error_msg) {
   DescriptorPool pool;
   for (int i = 0; i < request.proto_file_size(); i++) {
     const FileDescriptor* file = pool.BuildFile(request.proto_file(i));
     if (file == NULL) {
       // BuildFile() already wrote an error message.
       return false;
     }
   }
 
-  std::vector<const FileDescriptor*> parsed_files;
+  vector<const FileDescriptor*> parsed_files;
   for (int i = 0; i < request.file_to_generate_size(); i++) {
     parsed_files.push_back(pool.FindFileByName(request.file_to_generate(i)));
     if (parsed_files.back() == NULL) {
       *error_msg = "protoc asked plugin to generate a file but "
                    "did not provide a descriptor for the file: " +
                    request.file_to_generate(i);
       return false;
     }
   }
 
-  GeneratorResponseContext context(
-      request.compiler_version(), response, parsed_files);
+  GeneratorResponseContext context(response, parsed_files);
 
-  string error;
-  bool succeeded = generator.GenerateAll(
-      parsed_files, request.parameter(), &context, &error);
+  if (generator.HasGenerateAll()) {
+    string error;
+    bool succeeded = generator.GenerateAll(
+        parsed_files, request.parameter(), &context, &error);
 
-  if (!succeeded && error.empty()) {
-    error = "Code generator returned false but provided no error "
-            "description.";
-  }
-  if (!error.empty()) {
-    response->set_error(error);
+    if (!succeeded && error.empty()) {
+      error = "Code generator returned false but provided no error "
+              "description.";
+    }
+    if (!error.empty()) {
+      response->set_error(error);
+    }
+  } else {
+    for (int i = 0; i < parsed_files.size(); i++) {
+      const FileDescriptor* file = parsed_files[i];
+
+      string error;
+      bool succeeded = generator.Generate(
+          file, request.parameter(), &context, &error);
+
+      if (!succeeded && error.empty()) {
+        error = "Code generator returned false but provided no error "
+                "description.";
+      }
+      if (!error.empty()) {
+        response->set_error(file->name() + ": " + error);
+        break;
+      }
+    }
   }
 
   return true;
 }
 
 int PluginMain(int argc, char* argv[], const CodeGenerator* generator) {
 
   if (argc > 1) {
     std::cerr << argv[0] << ": Unknown option: " << argv[1] << std::endl;
     return 1;
@@ skipping 25 matching lines @@
     }
     return 1;
   }
 
   return 0;
 }
 
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google