third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/java/java_context.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 24 matching lines @@
 #include <google/protobuf/compiler/java/java_name_resolver.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/map_util.h>
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace java {
 
-Context::Context(const FileDescriptor* file)
-    : name_resolver_(new ClassNameResolver), enforce_lite_(false) {
+Context::Context(const FileDescriptor* file, const Options& options)
+    : name_resolver_(new ClassNameResolver), options_(options) {
   InitializeFieldGeneratorInfo(file);
 }
 
 Context::~Context() {
 }
 
 ClassNameResolver* Context::GetNameResolver() {
   return name_resolver_.get();
 }
 
@@ skipping 44 matching lines @@
   for (int i = 0; i < file->message_type_count(); ++i) {
     InitializeFieldGeneratorInfoForMessage(file->message_type(i));
   }
 }
 
 void Context::InitializeFieldGeneratorInfoForMessage(
     const Descriptor* message) {
   for (int i = 0; i < message->nested_type_count(); ++i) {
     InitializeFieldGeneratorInfoForMessage(message->nested_type(i));
   }
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   for (int i = 0; i < message->field_count(); ++i) {
     fields.push_back(message->field(i));
   }
   InitializeFieldGeneratorInfoForFields(fields);
 
   for (int i = 0; i < message->oneof_decl_count(); ++i) {
     const OneofDescriptor* oneof = message->oneof_decl(i);
     OneofGeneratorInfo info;
     info.name = UnderscoresToCamelCase(oneof->name(), false);
     info.capitalized_name = UnderscoresToCamelCase(oneof->name(), true);
     oneof_generator_info_map_[oneof] = info;
   }
 }
 
 void Context::InitializeFieldGeneratorInfoForFields(
-    const vector<const FieldDescriptor*>& fields) {
+    const std::vector<const FieldDescriptor*>& fields) {
   // Find out all fields that conflict with some other field in the same
   // message.
-  vector<bool> is_conflict(fields.size());
-  vector<string> conflict_reason(fields.size());
+  std::vector<bool> is_conflict(fields.size());
+  std::vector<string> conflict_reason(fields.size());
   for (int i = 0; i < fields.size(); ++i) {
     const FieldDescriptor* field = fields[i];
     const string& name = UnderscoresToCapitalizedCamelCase(field);
     for (int j = i + 1; j < fields.size(); ++j) {
       const FieldDescriptor* other = fields[j];
       const string& other_name = UnderscoresToCapitalizedCamelCase(other);
       if (name == other_name) {
         is_conflict[i] = is_conflict[j] = true;
         conflict_reason[i] = conflict_reason[j] =
             "capitalized name of field \"" + field->name() +
@@ skipping 43 matching lines @@
   if (result == NULL) {
     GOOGLE_LOG(FATAL) << "Can not find OneofGeneratorInfo for oneof: "
                << oneof->name();
   }
   return result;
 }
 
 // Does this message class have generated parsing, serialization, and other
 // standard methods for which reflection-based fallback implementations exist?
 bool Context::HasGeneratedMethods(const Descriptor* descriptor) const {
-  return enforce_lite_ || descriptor->file()->options().optimize_for() !=
-           FileOptions::CODE_SIZE;
+  return options_.enforce_lite ||
+         descriptor->file()->options().optimize_for() != FileOptions::CODE_SIZE;
 }
 
 }  // namespace java
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google