diff --git a/user/src/com/google/gwt/resources/client/CssResource.java b/user/src/com/google/gwt/resources/client/CssResource.java
index 1578095..c55cb20 100644
--- a/user/src/com/google/gwt/resources/client/CssResource.java
+++ b/user/src/com/google/gwt/resources/client/CssResource.java
@@ -148,7 +148,7 @@
  */
 @DefaultExtensions(value = {".css"})
 @ResourceGeneratorType(CssResourceGenerator.class)
-public interface CssResource extends ResourcePrototype {
+public interface CssResource extends CssResourceBase {
   /**
    * The original CSS class name specified in the resource. This allows CSS
    * classes that do not correspond to Java identifiers to be mapped onto
diff --git a/user/src/com/google/gwt/resources/client/CssResourceBase.java b/user/src/com/google/gwt/resources/client/CssResourceBase.java
new file mode 100644
index 0000000..49f17a4
--- /dev/null
+++ b/user/src/com/google/gwt/resources/client/CssResourceBase.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.client;
+
+/**
+ * Marker interface for all classes that should be obfuscated together in
+ * Css Resource generation.
+ * TODO(unnurg): Try to get rid of the global obfuscation scheme and delete
+ * this interface.
+ */
+public interface CssResourceBase extends ResourcePrototype { }
diff --git a/user/src/com/google/gwt/resources/rg/CssObfuscationStyle.java b/user/src/com/google/gwt/resources/rg/CssObfuscationStyle.java
new file mode 100644
index 0000000..fc582ae
--- /dev/null
+++ b/user/src/com/google/gwt/resources/rg/CssObfuscationStyle.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.resources.rg;
+
+import com.google.gwt.core.ext.typeinfo.JClassType;
+
+/**
+ * Evaluates the obfuscation style the user selected and formats the obfuscated
+ * name accordingly.
+ */
+public enum CssObfuscationStyle {
+  VERBOSE (true, false, true, true),
+  STABLE_FULL_CLASSNAME (true, true, true, true),
+  STABLE_SHORT_CLASSNAME (true, true, true, false),
+  STABLE_NO_CLASSNAME (true, true, false, false),
+  OBFUSCATED (false, false, false, false);
+
+  static CssObfuscationStyle getObfuscationStyle(String name) {
+    if (name.equalsIgnoreCase("pretty")) {
+      return VERBOSE;
+    } else if (name.equalsIgnoreCase("stable")) {
+      return STABLE_FULL_CLASSNAME;
+    } else if (name.equalsIgnoreCase("stable-shorttype")) {
+      return STABLE_SHORT_CLASSNAME;
+    } else if (name.equalsIgnoreCase("stable-notype")) {
+      return STABLE_NO_CLASSNAME;
+    }
+    return OBFUSCATED;
+  }
+
+  private boolean isPretty;
+  private boolean isStable;
+  private boolean showClassName;
+  private boolean showPackageName;
+  
+  CssObfuscationStyle(boolean isPretty, boolean isStable, boolean showClassName,
+      boolean showPackageName) {
+    this.isPretty = isPretty;
+    this.isStable = isStable;
+    this.showClassName = showClassName;
+    this.showPackageName = showPackageName;
+  }
+
+  public String getPrettyName(String method, JClassType type, String obfuscatedName) {
+    if (!isPretty()) {
+      return obfuscatedName;
+    }
+    String toReturn = method;
+    
+    /* 
+     * Note that by dropping the type, or using it's short name, you are 
+     * allowing name collisions in the css selector names. These options should
+     * only be used if you are sure that your GWT application is ensuring that 
+     * there are no namespace collisions.
+     */
+    if (showClassName) {
+      if (showPackageName) {
+        toReturn = type.getQualifiedSourceName().replaceAll("[.$]", "-") + "-" + toReturn;
+      } else {
+        toReturn = type.getName() + "-" + toReturn;
+      }
+    } 
+    
+    /*
+     * For stable styles the obfuscated class name is dropped from the pretty
+     * output. This results in class names that are constant, no matter how 
+     * many other selectors are added.
+     */
+    if (!isStable) {
+      toReturn = obfuscatedName += "-" + toReturn; 
+    }
+    return toReturn;
+  }
+
+  public boolean isPretty() {
+    return isPretty;
+  }
+}
diff --git a/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java b/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java
index 0a30503..fd44dbf 100644
--- a/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java
+++ b/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java
@@ -28,7 +28,6 @@
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.dev.util.DefaultTextOutput;
 import com.google.gwt.dev.util.Util;
-import com.google.gwt.dom.client.Element;
 import com.google.gwt.dom.client.StyleInjector;
 import com.google.gwt.i18n.client.LocaleInfo;
 import com.google.gwt.resources.client.CssResource;
@@ -37,6 +36,7 @@
 import com.google.gwt.resources.client.CssResource.ImportedWithPrefix;
 import com.google.gwt.resources.client.CssResource.NotStrict;
 import com.google.gwt.resources.client.CssResource.Shared;
+import com.google.gwt.resources.client.CssResourceBase;
 import com.google.gwt.resources.css.ClassRenamer;
 import com.google.gwt.resources.css.CssGenerationVisitor;
 import com.google.gwt.resources.css.DefsCollector;
@@ -245,7 +245,7 @@
    * given node. Visible only for testing.
    */
   static <T extends CssNode & HasNodes> String makeExpression(
-      TreeLogger logger, ResourceContext context, JClassType cssResourceType,
+      TreeLogger logger, ResourceContext context,
       T node, boolean prettyOutput) throws UnableToCompleteException {
     // Generate the CSS template
     DefaultTextOutput out = new DefaultTextOutput(!prettyOutput);
@@ -285,7 +285,7 @@
 
           // Generate the sub-expressions
           String expression = makeExpression(loopLogger, context,
-              cssResourceType, new CollapsedNode(asIf), prettyOutput);
+              new CollapsedNode(asIf), prettyOutput);
 
           String elseExpression;
           if (asIf.getElseNodes().isEmpty()) {
@@ -293,8 +293,7 @@
             elseExpression = "\"\"";
           } else {
             elseExpression = makeExpression(loopLogger, context,
-                cssResourceType, new CollapsedNode(asIf.getElseNodes()),
-                prettyOutput);
+                new CollapsedNode(asIf.getElseNodes()), prettyOutput);
           }
 
           // ((expr) ? "CSS" : "elseCSS") +
@@ -423,54 +422,29 @@
     }
   }
 
-  protected List<String> ignoredMethods = new ArrayList<String>();
-  protected Map<JMethod, CssStylesheet> stylesheetMap;
+  protected CssObfuscationStyle obfuscationStyle;
   private Counter classCounter;
-  private JClassType cssResourceType;
-  private JClassType elementType;
   private boolean enableMerge;
-  private boolean prettyOutput;
+  private List<String> ignoredMethods = new ArrayList<String>();
   private Map<JClassType, Map<JMethod, String>> replacementsByClassAndMethod;
   private Map<JMethod, String> replacementsForSharedMethods;
-  private JClassType stringType;
+  private Map<JMethod, CssStylesheet> stylesheetMap;
 
   @Override
   public String createAssignment(TreeLogger logger, ResourceContext context,
       JMethod method) throws UnableToCompleteException {
-
-    TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
-    SourceWriter sw = new StringSourceWriter();
-    // Write the expression to create the subtype.
-    sw.println("new " + method.getReturnType().getQualifiedSourceName()
-        + "() {");
-    sw.indent();
-
     JClassType cssResourceSubtype = method.getReturnType().isInterface();
     assert cssResourceSubtype != null;
-
-    // Compute the local effective namespace
-    Map<String, Map<JMethod, String>> replacementsWithPrefix = processImports(
-        logger, typeOracle, cssResourceSubtype, method, context);
-
-    // Methods defined by CssResource interface
-    writeEnsureInjected(sw);
-    writeGetName(method, sw);
-  
-    // Create the Java expression that generates the CSS
-    Map<JMethod, String> actualReplacements = writeGetText(logger, context,
-        method, sw, cssResourceSubtype, replacementsWithPrefix);
-   
-    /*
-     * getOverridableMethods is used to handle CssResources extending
-     * non-CssResource types. See the discussion in computeReplacementsForType.
-     */
-    writeUserMethods(logger, sw, stylesheetMap.get(method),
-        cssResourceSubtype.getOverridableMethods(), actualReplacements);
-   
-    sw.outdent();
-    sw.println("}");
-   
-    return sw.toString();
+    CssStylesheet stylesheet = stylesheetMap.get(method);
+       
+    // Optimize the stylesheet, recording the class selector obfuscations
+    Map<JMethod, String> actualReplacements = optimize(logger, context, method);
+    
+    outputAdditionalArtifacts(logger, context, method, actualReplacements,
+        cssResourceSubtype, stylesheet);
+    
+    return getResourceImplAsString(logger, context, method, actualReplacements,
+        cssResourceSubtype, stylesheet);
   }
 
   @Override
@@ -482,9 +456,9 @@
         context.getGeneratorContext().getPropertyOracle();
       ConfigurationProperty styleProp = 
         propertyOracle.getConfigurationProperty(KEY_STYLE);
-      String style = styleProp.getValues().get(0);
-      prettyOutput = style.equals("pretty");
-
+      obfuscationStyle = CssObfuscationStyle.getObfuscationStyle(
+          styleProp.getValues().get(0));
+      
       ConfigurationProperty mergeProp = 
         propertyOracle.getConfigurationProperty(KEY_MERGE_ENABLED);
       String merge = mergeProp.getValues().get(0);
@@ -505,16 +479,18 @@
     }
 
     TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
-    JClassType baseInterface = typeOracle.findType(getBaseInterfaceName());
-    for (JMethod m : baseInterface.getInheritableMethods()) {
+    JClassType superInterface = typeOracle.findType(getSuperclassInterfaceName());
+    JClassType baseInterface = typeOracle.findType(getBaseclassInterfaceName());
+
+    for (JMethod m : superInterface.getInheritableMethods()) {
       ignoredMethods.add(m.getName());
     }
 
-    // Find all of the types that we care about in the type system
-    checkTypes(context, typeOracle);
     stylesheetMap = new IdentityHashMap<JMethod, CssStylesheet>();
     
-    initReplacements(logger, context, classPrefix);
+    SortedSet<JClassType> cssResourceSubtypes =
+      computeOperableTypes(logger, baseInterface);
+    initReplacements(logger, context, classPrefix, cssResourceSubtypes);
   }
 
   @Override
@@ -527,9 +503,7 @@
       throw new UnableToCompleteException();
     }
 
-    URL[] resources = ResourceGeneratorUtil.findResources(logger, context,
-        method);
-
+    URL[] resources = getResources(logger, context, method);
     if (resources.length == 0) {
       logger.log(TreeLogger.ERROR, "At least one source must be specified");
       throw new UnableToCompleteException();
@@ -537,120 +511,81 @@
 
     // Create the AST and do a quick scan for requirements
     CssStylesheet sheet = GenerateCssAst.exec(logger, resources);
+    checkSheet(logger, sheet);
     stylesheetMap.put(method, sheet);
     (new RequirementsCollector(logger, context.getRequirements())).accept(sheet);    
   }
-
-  protected void checkTypes(ResourceContext context, TypeOracle typeOracle) {
-    cssResourceType = typeOracle.findType(CssResource.class.getName());
-    assert cssResourceType != null;
-
-    elementType = typeOracle.findType(Element.class.getName());
-    assert elementType != null;
-
-    stringType = typeOracle.findType(String.class.getName());
-    assert stringType != null;
-  }
   
-  protected String getBaseInterfaceName() {
-    return CssResource.class.getCanonicalName();
+  protected void checkSheet(TreeLogger logger, CssStylesheet stylesheet)
+  throws UnableToCompleteException {
+    // Do nothing
   }
+ 
+  /**
+   * Return the name of the class which is at the base of the CssResource
+   * generation tree.  Since obfuscation is done globally, this should be the
+   * base class for all resources in the compilation that should be included
+   * in the global obfuscation.
+   */
+  protected String getBaseclassInterfaceName() {
+    return CssResourceBase.class.getCanonicalName();
+  }
+
+  protected String getResourceImplAsString(TreeLogger logger, ResourceContext context,
+      JMethod method, Map<JMethod, String> actualReplacements,
+      JClassType cssResourceSubtype,
+      CssStylesheet stylesheet) throws UnableToCompleteException {
+    SourceWriter sw = new StringSourceWriter();
+    // Write the expression to create the subtype.
+    sw.println("new " + method.getReturnType().getQualifiedSourceName()
+        + "() {");
+    sw.indent();
+
+    // Methods defined by CssResource interface
+    writeEnsureInjected(sw);
+    writeGetName(method, sw);
   
-  protected String makeExpressionForSheet(
-      TreeLogger logger, ResourceContext context, JClassType cssResourceType,
-      CssStylesheet sheet, boolean prettyOutput) throws UnableToCompleteException {
-    return makeExpression(logger, context, cssResourceType, sheet, prettyOutput);
+    // Create the Java expression that generates the CSS
+    writeGetText(logger, context, method, sw);
+   
+    // getOverridableMethods is used to handle CssResources extending
+    // non-CssResource types. See the discussion in computeReplacementsForType.
+    writeUserMethods(logger, sw, stylesheet,
+        cssResourceSubtype.getOverridableMethods(), actualReplacements);
+   
+    sw.outdent();
+    sw.println("}");
+   
+    return sw.toString();
   }
 
-  protected void optimize(TreeLogger logger, ResourceContext context,
-      JMethod method,
-      Map<String, Map<JMethod, String>> classReplacementsWithPrefix,
-      Map<JMethod, String> actualReplacements) {
-    boolean strict = isStrict(logger, method);
-    CssStylesheet sheet = stylesheetMap.get(method);
-    
-    // Create CSS sprites
-    (new Spriter(logger, context)).accept(sheet);
-
-    // Perform @def and @eval substitutions
-    SubstitutionCollector collector = new SubstitutionCollector();
-    collector.accept(sheet);
-
-    (new SubstitutionReplacer(logger, context, collector.getSubstitutions()))
-    .accept(sheet);
-
-    // Evaluate @if statements based on deferred binding properties
-    (new IfEvaluator(logger,
-        context.getGeneratorContext().getPropertyOracle())).accept(sheet);
-
-    // Rename css .class selectors. We look for all @external declarations in
-    // the stylesheet and then compute the per-instance replacements.
-    ExternalClassesCollector externalClasses = new ExternalClassesCollector();
-    externalClasses.accept(sheet);
-    ClassRenamer renamer = new ClassRenamer(logger,
-        classReplacementsWithPrefix, strict, externalClasses.getClasses());
-    renamer.accept(sheet);
-    actualReplacements.putAll(renamer.getReplacements());
-
-    // Combine rules with identical selectors
-    if (enableMerge) {
-      (new SplitRulesVisitor()).accept(sheet);
-      (new MergeIdenticalSelectorsVisitor()).accept(sheet);
-      (new MergeRulesByContentVisitor()).accept(sheet);
-    } 
+  protected URL[] getResources(TreeLogger logger, ResourceContext context,
+      JMethod method) throws UnableToCompleteException {
+    return ResourceGeneratorUtil.findResources(logger, context, method);
   }
 
   /**
-   * Process the Import annotation on the associated JMethod and return a map of
-   * prefixes to JMethods to locally obfuscated names.
+   * Return the name of the class which is the direct superclass of the
+   * interface being implemented.
    */
-  protected Map<String, Map<JMethod, String>> processImports(TreeLogger logger,
-      TypeOracle typeOracle, JClassType cssResourceSubtype, JMethod method,
-      ResourceContext context)
-      throws UnableToCompleteException {
-    Map<String, Map<JMethod, String>> replacementsWithPrefix =
-      new HashMap<String, Map<JMethod, String>>();
-
-    replacementsWithPrefix.put("",
-        computeReplacementsForType(cssResourceSubtype));
-    Import imp = method.getAnnotation(Import.class);
-    if (imp != null) {
-      boolean fail = false;
-      for (Class<? extends CssResource> clazz : imp.value()) {
-        JClassType importType = typeOracle.findType(clazz.getName().replace(
-            '$', '.'));
-        assert importType != null : "TypeOracle does not have type "
-            + clazz.getName();
-
-        // add this import type as a requirement for this generator
-        context.getRequirements().addTypeHierarchy(importType);
-        
-        String prefix = getImportPrefix(importType);
-
-        if (replacementsWithPrefix.put(prefix,
-            computeReplacementsForType(importType)) != null) {
-          logger.log(TreeLogger.ERROR,
-              "Multiple imports that would use the prefix " + prefix);
-          fail = true;
-        }
-      }
-      if (fail) {
-        throw new UnableToCompleteException();
-      }  
-    }
-    return replacementsWithPrefix;
+  protected String getSuperclassInterfaceName() {
+    return CssResource.class.getCanonicalName();
+  }
+  
+  /**
+   * Output additional artifacts. Does nothing in this baseclass, but is a hook
+   * for subclasses to do so.
+   */
+  protected void outputAdditionalArtifacts(TreeLogger logger, 
+      ResourceContext context, JMethod method, 
+      Map<JMethod, String> actualReplacements, JClassType cssResourceSubtype,
+      CssStylesheet stylesheet) throws UnableToCompleteException {
   }
 
-  protected void writeEnsureInjected(SourceWriter sw) {
-    sw.println("private boolean injected;");
-    sw.println("public boolean ensureInjected() {");
+  protected void writeGetName(JMethod method, SourceWriter sw) {
+    sw.println("public String getName() {");
     sw.indent();
-    sw.println("if (!injected) {");
-    sw.indentln("injected = true;");
-    sw.indentln(StyleInjector.class.getName() + ".inject(getText());");
-    sw.indentln("return true;");
-    sw.println("}");
-    sw.println("return false;");
+    sw.println("return \"" + method.getName() + "\";");
     sw.outdent();
     sw.println("}");
   }
@@ -684,7 +619,8 @@
       if (defs.contains(toImplement.getName())
           && toImplement.getParameters().length == 0) {
         writeDefAssignment(logger, sw, toImplement, sheet);
-      } else if (toImplement.getReturnType().equals(stringType)
+      } else if (toImplement.getReturnType().getQualifiedSourceName()
+          .equals("java.lang.String")
           && toImplement.getParameters().length == 0) {
         writeClassAssignment(sw, toImplement, obfuscatedClassNames);
       } else {
@@ -695,6 +631,7 @@
     }
   }
 
+
   /**
    * Determine the class prefix that will be used. If a value is automatically
    * computed, the <code>reservedPrefixes</code> set will be cleared because the
@@ -763,14 +700,16 @@
           name = classNameOverride.value();
         }
 
+        /*
+         * Short name, based off a counter that is shared by all of the
+         * obfuscated css names in this compile.
+         */
         String obfuscatedClassName = computeObfuscatedClassName(classPrefix,
             classCounter, reservedPrefixes);
-
-        if (prettyOutput) {
-          obfuscatedClassName += "-"
-              + type.getQualifiedSourceName().replaceAll("[.$]", "-") + "-"
-              + name;
-        }
+        
+        // Modify the name based on the obfuscation style requested
+        obfuscatedClassName = obfuscationStyle.getPrettyName(name, type,
+              obfuscatedClassName);
 
         replacements.put(method, obfuscatedClassName);
 
@@ -802,14 +741,15 @@
    * there is presently no way to determine when, or by what means, a type was
    * added to the TypeOracle.
    */
-  private SortedSet<JClassType> computeOperableTypes(TreeLogger logger) {
+  private SortedSet<JClassType> computeOperableTypes(TreeLogger logger,
+      JClassType baseInterface) {
     logger = logger.branch(TreeLogger.DEBUG,
         "Finding operable CssResource subtypes");
 
     SortedSet<JClassType> toReturn = new TreeSet<JClassType>(
         new JClassOrderComparator());
 
-    JClassType[] cssResourceSubtypes = cssResourceType.getSubtypes();
+    JClassType[] cssResourceSubtypes = baseInterface.getSubtypes();
     for (JClassType type : cssResourceSubtypes) {
       if (type.isInterface() != null) {
         logger.log(TreeLogger.SPAM, "Added " + type.getQualifiedSourceName());
@@ -831,16 +771,6 @@
   private Map<JMethod, String> computeReplacementsForType(JClassType type) {
     Map<JMethod, String> toReturn = new IdentityHashMap<JMethod, String>();
 
-    /*
-     * We check to see if the type is derived from CssResource so that we can
-     * handle the case of a CssResource type being derived from a
-     * non-CssResource base type. This basically collapses the non-CssResource
-     * base types into their least-derived CssResource subtypes.
-     */
-    if (type == null || !derivedFromCssResource(type)) {
-      return toReturn;
-    }
-
     if (replacementsByClassAndMethod.containsKey(type)) {
       toReturn.putAll(replacementsByClassAndMethod.get(type));
     }
@@ -858,11 +788,11 @@
 
     return toReturn;
   }
-
+  
   /**
    * Determine if a type is derived from CssResource.
    */
-  private boolean derivedFromCssResource(JClassType type) {
+  private boolean derivedFromCssResource(JClassType type, JClassType cssResourceType) {
     List<JClassType> superInterfaces = Arrays.asList(type.getImplementedInterfaces());
     if (superInterfaces.contains(cssResourceType)) {
       return true;
@@ -870,13 +800,13 @@
 
     JClassType superClass = type.getSuperclass();
     if (superClass != null) {
-      if (derivedFromCssResource(superClass)) {
+      if (derivedFromCssResource(superClass, cssResourceType)) {
         return true;
       }
     }
 
     for (JClassType superInterface : superInterfaces) {
-      if (derivedFromCssResource(superInterface)) {
+      if (derivedFromCssResource(superInterface, cssResourceType)) {
         return true;
       }
     }
@@ -889,7 +819,7 @@
    */
   @SuppressWarnings("unchecked")
   private void initReplacements(TreeLogger logger, ResourceContext context,
-      String classPrefix) {
+      String classPrefix, SortedSet<JClassType> operableTypes) {
     /*
      * This code was originally written to take a snapshot of all the
      * CssResource descendants in the TypeOracle on its first run and calculate
@@ -903,9 +833,7 @@
      * so the old gymnastics aren't really justified anyway. It would probably
      * be be worth the effort to simplify this.
      */
-
-    SortedSet<JClassType> cssResourceSubtypes = computeOperableTypes(logger);
-
+    
     if (context.getCachedData(KEY_HAS_CACHED_DATA, Boolean.class) != Boolean.TRUE) {
 
       ConfigurationProperty prop;
@@ -937,7 +865,7 @@
       }
 
       String computedPrefix = computeClassPrefix(classPrefix,
-          cssResourceSubtypes, reservedPrefixes);
+          operableTypes, reservedPrefixes);
 
       context.putCachedData(KEY_BY_CLASS_AND_METHOD,
           new IdentityHashMap<JClassType, Map<JMethod, String>>());
@@ -960,7 +888,7 @@
         KEY_RESERVED_PREFIXES, SortedSet.class);
 
     computeObfuscatedNames(logger, classPrefix, reservedPrefixes,
-        cssResourceSubtypes);
+        operableTypes);
   }
 
   /**
@@ -1000,20 +928,12 @@
    *          modifications encoded in the source CSS file
    */
   private String makeExpression(TreeLogger logger, ResourceContext context,
-      JClassType cssResourceType, CssStylesheet sheet,
-      Map<String, Map<JMethod, String>> classReplacementsWithPrefix,
-      JMethod method, Map<JMethod, String> actualReplacements)
+      CssStylesheet sheet)
       throws UnableToCompleteException {
-
     try {
-      optimize(logger, context, method, classReplacementsWithPrefix,
-          actualReplacements);
-      
-      String standard = makeExpressionForSheet(logger, context, cssResourceType,
-          sheet, prettyOutput);
+      String standard = makeExpression(logger, context, sheet, obfuscationStyle.isPretty());
       (new RtlVisitor()).accept(sheet);
-      String reversed = makeExpressionForSheet(logger, context, cssResourceType,
-          sheet, prettyOutput);
+      String reversed = makeExpression(logger, context, sheet, obfuscationStyle.isPretty());
       
       if (standard.equals(reversed)) {
         return standard;
@@ -1030,6 +950,97 @@
     }
   }
 
+  private Map<JMethod, String> optimize(TreeLogger logger,
+      ResourceContext context, JMethod method) throws UnableToCompleteException {
+    
+    TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
+    JClassType cssResourceSubtype = method.getReturnType().isInterface();
+    assert cssResourceSubtype != null;
+    assert derivedFromCssResource(cssResourceSubtype,
+        typeOracle.findType(getBaseclassInterfaceName()));
+
+    // Compute the local effective namespace
+    Map<String, Map<JMethod, String>> classReplacementsWithPrefix = processImports(
+        logger, typeOracle, cssResourceSubtype, method, context);
+
+    boolean strict = isStrict(logger, method);
+    CssStylesheet sheet = stylesheetMap.get(method);
+    
+    // Create CSS sprites
+    (new Spriter(logger, context)).accept(sheet);
+
+    // Perform @def and @eval substitutions
+    SubstitutionCollector collector = new SubstitutionCollector();
+    collector.accept(sheet);
+
+    (new SubstitutionReplacer(logger, context, collector.getSubstitutions()))
+    .accept(sheet);
+
+    // Evaluate @if statements based on deferred binding properties
+    (new IfEvaluator(logger,
+        context.getGeneratorContext().getPropertyOracle())).accept(sheet);
+
+    // Rename css .class selectors. We look for all @external declarations in
+    // the stylesheet and then compute the per-instance replacements.
+    ExternalClassesCollector externalClasses = new ExternalClassesCollector();
+    externalClasses.accept(sheet);
+    ClassRenamer renamer = new ClassRenamer(logger,
+        classReplacementsWithPrefix, strict, externalClasses.getClasses());
+    renamer.accept(sheet);
+    Map<JMethod, String> actualReplacements = new HashMap<JMethod, String>();
+    actualReplacements.putAll(renamer.getReplacements());
+
+    // Combine rules with identical selectors
+    if (enableMerge) {
+      (new SplitRulesVisitor()).accept(sheet);
+      (new MergeIdenticalSelectorsVisitor()).accept(sheet);
+      (new MergeRulesByContentVisitor()).accept(sheet);
+    } 
+    
+    return actualReplacements;
+  }
+
+  /**
+   * Process the Import annotation on the associated JMethod and return a map of
+   * prefixes to JMethods to locally obfuscated names.
+   */
+  private Map<String, Map<JMethod, String>> processImports(TreeLogger logger,
+      TypeOracle typeOracle, JClassType cssResourceSubtype, JMethod method,
+      ResourceContext context)
+      throws UnableToCompleteException {
+    Map<String, Map<JMethod, String>> replacementsWithPrefix =
+      new HashMap<String, Map<JMethod, String>>();
+
+    replacementsWithPrefix.put("",
+        computeReplacementsForType(cssResourceSubtype));
+    Import imp = method.getAnnotation(Import.class);
+    if (imp != null) {
+      boolean fail = false;
+      for (Class<? extends CssResource> clazz : imp.value()) {
+        JClassType importType = typeOracle.findType(clazz.getName().replace(
+            '$', '.'));
+        assert importType != null : "TypeOracle does not have type "
+            + clazz.getName();
+
+        // add this import type as a requirement for this generator
+        context.getRequirements().addTypeHierarchy(importType);
+        
+        String prefix = getImportPrefix(importType);
+
+        if (replacementsWithPrefix.put(prefix,
+            computeReplacementsForType(importType)) != null) {
+          logger.log(TreeLogger.ERROR,
+              "Multiple imports that would use the prefix " + prefix);
+          fail = true;
+        }
+      }
+      if (fail) {
+        throw new UnableToCompleteException();
+      }  
+    }
+    return replacementsWithPrefix;
+  }
+
   /**
    * Write the CssResource accessor method for simple String return values.
    */
@@ -1107,28 +1118,29 @@
     sw.println("}");
   }
 
-  private void writeGetName(JMethod method, SourceWriter sw) {
-    sw.println("public String getName() {");
+  private void writeEnsureInjected(SourceWriter sw) {
+    sw.println("private boolean injected;");
+    sw.println("public boolean ensureInjected() {");
     sw.indent();
-    sw.println("return \"" + method.getName() + "\";");
+    sw.println("if (!injected) {");
+    sw.indentln("injected = true;");
+    sw.indentln(StyleInjector.class.getName() + ".inject(getText());");
+    sw.indentln("return true;");
+    sw.println("}");
+    sw.println("return false;");
     sw.outdent();
     sw.println("}");
   }
 
-  private Map<JMethod, String> writeGetText(TreeLogger logger,
-      ResourceContext context, JMethod method, SourceWriter sw,
-      JClassType cssResourceSubtype,
-      Map<String, Map<JMethod, String>> replacementsWithPrefix)
+  private void writeGetText(TreeLogger logger,
+      ResourceContext context, JMethod method, SourceWriter sw)
       throws UnableToCompleteException {
     sw.println("public String getText() {");
     sw.indent();
-    Map<JMethod, String> actualReplacements = new IdentityHashMap<JMethod, String>();
-    String cssExpression = makeExpression(logger, context, cssResourceSubtype,
-        stylesheetMap.get(method), replacementsWithPrefix, method,
-        actualReplacements);
+    String cssExpression = makeExpression(logger, context,
+        stylesheetMap.get(method));
     sw.println("return " + cssExpression + ";");
     sw.outdent();
     sw.println("}");
-    return actualReplacements;
   }
 }
diff --git a/user/test/com/google/gwt/resources/rg/CssTestCase.java b/user/test/com/google/gwt/resources/rg/CssTestCase.java
index 6b46164..9ad51c2 100644
--- a/user/test/com/google/gwt/resources/rg/CssTestCase.java
+++ b/user/test/com/google/gwt/resources/rg/CssTestCase.java
@@ -131,9 +131,9 @@
   protected static <T extends CssNode & HasNodes> void assertEquals(
       TreeLogger logger, T expected, T test) throws UnableToCompleteException {
     String expectedCss = CssResourceGenerator.makeExpression(logger,
-        new FakeContext(), null, expected, false);
+        new FakeContext(), expected, false);
     String testCss = CssResourceGenerator.makeExpression(logger,
-        new FakeContext(), null, test, false);
+        new FakeContext(), test, false);
     assertEquals(expectedCss, testCss);
   }