Revert https://codereview.chromium.org/1291903002 (protobuf roll).

third_party/protobuf/src/google/protobuf/compiler/java/java_extension.cc

Index: third_party/protobuf/src/google/protobuf/compiler/java/java_extension.cc
diff --git a/third_party/protobuf/src/google/protobuf/compiler/java/java_extension.cc b/third_party/protobuf/src/google/protobuf/compiler/java/java_extension.cc
index 4db7085e01c6bf8835d978ea139aedad763cc837..921fe6589c2b9d01fb60b27626200f5d8afd88bc 100644
--- a/third_party/protobuf/src/google/protobuf/compiler/java/java_extension.cc
+++ b/third_party/protobuf/src/google/protobuf/compiler/java/java_extension.cc
@@ -1,6 +1,6 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// http://code.google.com/p/protobuf/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,50 +33,74 @@
 //  Sanjay Ghemawat, Jeff Dean, and others.
 
 #include <google/protobuf/compiler/java/java_extension.h>
-
-#include <google/protobuf/compiler/java/java_context.h>
 #include <google/protobuf/compiler/java/java_doc_comment.h>
 #include <google/protobuf/compiler/java/java_helpers.h>
-#include <google/protobuf/compiler/java/java_name_resolver.h>
-#include <google/protobuf/io/printer.h>
 #include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/io/printer.h>
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace java {
 
-ImmutableExtensionGenerator::ImmutableExtensionGenerator(
-    const FieldDescriptor* descriptor, Context* context)
-  : descriptor_(descriptor), context_(context),
-    name_resolver_(context->GetNameResolver()) {
+namespace {
+
+const char* TypeName(FieldDescriptor::Type field_type) {
+  switch (field_type) {
+    case FieldDescriptor::TYPE_INT32   : return "INT32";
+    case FieldDescriptor::TYPE_UINT32  : return "UINT32";
+    case FieldDescriptor::TYPE_SINT32  : return "SINT32";
+    case FieldDescriptor::TYPE_FIXED32 : return "FIXED32";
+    case FieldDescriptor::TYPE_SFIXED32: return "SFIXED32";
+    case FieldDescriptor::TYPE_INT64   : return "INT64";
+    case FieldDescriptor::TYPE_UINT64  : return "UINT64";
+    case FieldDescriptor::TYPE_SINT64  : return "SINT64";
+    case FieldDescriptor::TYPE_FIXED64 : return "FIXED64";
+    case FieldDescriptor::TYPE_SFIXED64: return "SFIXED64";
+    case FieldDescriptor::TYPE_FLOAT   : return "FLOAT";
+    case FieldDescriptor::TYPE_DOUBLE  : return "DOUBLE";
+    case FieldDescriptor::TYPE_BOOL    : return "BOOL";
+    case FieldDescriptor::TYPE_STRING  : return "STRING";
+    case FieldDescriptor::TYPE_BYTES   : return "BYTES";
+    case FieldDescriptor::TYPE_ENUM    : return "ENUM";
+    case FieldDescriptor::TYPE_GROUP   : return "GROUP";
+    case FieldDescriptor::TYPE_MESSAGE : return "MESSAGE";
+
+    // No default because we want the compiler to complain if any new
+    // types are added.
+  }
+
+  GOOGLE_LOG(FATAL) << "Can't get here.";
+  return NULL;
+}
+
+}
+
+ExtensionGenerator::ExtensionGenerator(const FieldDescriptor* descriptor)
+  : descriptor_(descriptor) {
   if (descriptor_->extension_scope() != NULL) {
-    scope_ = name_resolver_->GetImmutableClassName(
-        descriptor_->extension_scope());
+    scope_ = ClassName(descriptor_->extension_scope());
   } else {
-    scope_ = name_resolver_->GetImmutableClassName(descriptor_->file());
+    scope_ = ClassName(descriptor_->file());
   }
 }
 
-ImmutableExtensionGenerator::~ImmutableExtensionGenerator() {}
+ExtensionGenerator::~ExtensionGenerator() {}
 
 // Initializes the vars referenced in the generated code templates.
-void ExtensionGenerator::InitTemplateVars(const FieldDescriptor* descriptor,
-                                          const string& scope,
-                                          bool immutable,
-                                          ClassNameResolver* name_resolver,
-                                          map<string, string>* vars_pointer) {
+void InitTemplateVars(const FieldDescriptor* descriptor,
+                      const string& scope,
+                      map<string, string>* vars_pointer) {
   map<string, string> &vars = *vars_pointer;
   vars["scope"] = scope;
   vars["name"] = UnderscoresToCamelCase(descriptor);
-  vars["containing_type"] =
-      name_resolver->GetClassName(descriptor->containing_type(), immutable);
+  vars["containing_type"] = ClassName(descriptor->containing_type());
   vars["number"] = SimpleItoa(descriptor->number());
   vars["constant_name"] = FieldConstantName(descriptor);
   vars["index"] = SimpleItoa(descriptor->index());
-  vars["default"] = descriptor->is_repeated() ?
-      "" : DefaultValue(descriptor, immutable, name_resolver);
-  vars["type_constant"] = FieldTypeName(GetType(descriptor));
+  vars["default"] =
+      descriptor->is_repeated() ? "" : DefaultValue(descriptor);
+  vars["type_constant"] = TypeName(GetType(descriptor));
   vars["packed"] = descriptor->options().packed() ? "true" : "false";
   vars["enum_map"] = "null";
   vars["prototype"] = "null";
@@ -85,21 +109,13 @@ void ExtensionGenerator::InitTemplateVars(const FieldDescriptor* descriptor,
   string singular_type;
   switch (java_type) {
     case JAVATYPE_MESSAGE:
-      singular_type = name_resolver->GetClassName(descriptor->message_type(),
-                                                   immutable);
+      singular_type = ClassName(descriptor->message_type());
       vars["prototype"] = singular_type + ".getDefaultInstance()";
       break;
     case JAVATYPE_ENUM:
-      singular_type = name_resolver->GetClassName(descriptor->enum_type(),
-                                                   immutable);
+      singular_type = ClassName(descriptor->enum_type());
       vars["enum_map"] = singular_type + ".internalGetValueMap()";
       break;
-    case JAVATYPE_STRING:
-      singular_type = "java.lang.String";
-      break;
-    case JAVATYPE_BYTES:
-      singular_type = immutable ? "com.google.protobuf.ByteString" : "byte[]";
-      break;
     default:
       singular_type = BoxedPrimitiveTypeName(java_type);
       break;
@@ -109,11 +125,9 @@ void ExtensionGenerator::InitTemplateVars(const FieldDescriptor* descriptor,
   vars["singular_type"] = singular_type;
 }
 
-void ImmutableExtensionGenerator::Generate(io::Printer* printer) {
+void ExtensionGenerator::Generate(io::Printer* printer) {
   map<string, string> vars;
-  const bool kUseImmutableNames = true;
-  InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_,
-                   &vars);
+  InitTemplateVars(descriptor_, scope_, &vars);
   printer->Print(vars,
       "public static final int $constant_name$ = $number$;\n");
 
@@ -160,8 +174,7 @@ void ImmutableExtensionGenerator::Generate(io::Printer* printer) {
           "      $enum_map$,\n"
           "      $number$,\n"
           "      com.google.protobuf.WireFormat.FieldType.$type_constant$,\n"
-          "      $packed$,\n"
-          "      $singular_type$.class);\n");
+          "      $packed$);\n");
     } else {
       printer->Print(
           vars,
@@ -175,15 +188,13 @@ void ImmutableExtensionGenerator::Generate(io::Printer* printer) {
           "      $prototype$,\n"
           "      $enum_map$,\n"
           "      $number$,\n"
-          "      com.google.protobuf.WireFormat.FieldType.$type_constant$,\n"
-          "      $singular_type$.class);\n");
+          "      com.google.protobuf.WireFormat.FieldType.$type_constant$);\n");
     }
   }
 }
 
-int ImmutableExtensionGenerator::GenerateNonNestedInitializationCode(
+void ExtensionGenerator::GenerateNonNestedInitializationCode(
     io::Printer* printer) {
-  int bytecode_estimate = 0;
   if (descriptor_->extension_scope() == NULL &&
       HasDescriptorMethods(descriptor_->file())) {
     // Only applies to non-nested, non-lite extensions.
@@ -191,18 +202,14 @@ int ImmutableExtensionGenerator::GenerateNonNestedInitializationCode(
         "$name$.internalInit(descriptor.getExtensions().get($index$));\n",
         "name", UnderscoresToCamelCase(descriptor_),
         "index", SimpleItoa(descriptor_->index()));
-    bytecode_estimate += 21;
   }
-  return bytecode_estimate;
 }
 
-int ImmutableExtensionGenerator::GenerateRegistrationCode(
-    io::Printer* printer) {
+void ExtensionGenerator::GenerateRegistrationCode(io::Printer* printer) {
   printer->Print(
     "registry.add($scope$.$name$);\n",
     "scope", scope_,
     "name", UnderscoresToCamelCase(descriptor_));
-  return 7;
 }
 
 }  // namespace java