diff --git a/common.xml b/common.xml
index 6401b21..d3ab4ed 100644
--- a/common.xml
+++ b/common.xml
@@ -44,10 +44,6 @@
 
     <property name="Export-Package" value="!${module}.internal.*,${module}.*;version=${api.version}"/>
 
-    <condition property="Eclipse-ExtensibleAPI" value="true">
-      <equals arg1="${module}" arg2="com.google.inject"/>
-    </condition>
-
     <condition property="Import-Package" value="!com.google.inject.*,*" else="!${module}.*,${imports},*">
       <istrue value="${fragment}"/>
     </condition>
diff --git a/core/pom.xml b/core/pom.xml
index 9ac81be..3df788b 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -98,11 +98,6 @@
       <plugin>
         <groupId>org.apache.felix</groupId>
         <artifactId>maven-bundle-plugin</artifactId>
-        <configuration>
-          <instructions>
-            <Eclipse-ExtensibleAPI>true</Eclipse-ExtensibleAPI>
-          </instructions>
-        </configuration>
       </plugin>
       <!--
        | Remove duplicate jarjar'd LICENSE and NOTICE
diff --git a/extensions/grapher/test/com/google/inject/grapher/AbstractInjectorGrapherTest.java b/extensions/grapher/test/com/google/inject/grapher/AbstractInjectorGrapherTest.java
index b5ee53f..8d90f4c 100644
--- a/extensions/grapher/test/com/google/inject/grapher/AbstractInjectorGrapherTest.java
+++ b/extensions/grapher/test/com/google/inject/grapher/AbstractInjectorGrapherTest.java
@@ -26,6 +26,7 @@
 import com.google.inject.Key;
 import com.google.inject.Provider;
 import com.google.inject.spi.InjectionPoint;
+import com.google.testing.testsize.MediumTest;
 
 import junit.framework.TestCase;
 
@@ -40,6 +41,7 @@
  *
  * @author bojand@google.com (Bojan Djordjevic)
  */
+@MediumTest
 public class AbstractInjectorGrapherTest extends TestCase {
   private static final String TEST_STRING = "test";
 
diff --git a/extensions/servlet/src/com/google/inject/servlet/ServletScopes.java b/extensions/servlet/src/com/google/inject/servlet/ServletScopes.java
index acc7229..156e9c6 100644
--- a/extensions/servlet/src/com/google/inject/servlet/ServletScopes.java
+++ b/extensions/servlet/src/com/google/inject/servlet/ServletScopes.java
@@ -19,12 +19,18 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Maps;
+import com.google.inject.Binding;
+import com.google.inject.Injector;
 import com.google.inject.Key;
 import com.google.inject.OutOfScopeException;
 import com.google.inject.Provider;
 import com.google.inject.Scope;
 import com.google.inject.Scopes;
+import com.google.inject.internal.LinkedBindingImpl;
+import com.google.inject.spi.BindingScopingVisitor;
+import com.google.inject.spi.ExposedBinding;
 
+import java.lang.annotation.Annotation;
 import java.util.Map;
 import java.util.concurrent.Callable;
 
@@ -47,6 +53,14 @@
       Key.get(HttpServletResponse.class),
       new Key<Map<String, String[]>>(RequestParameters.class) {});
 
+  /**
+   * A threadlocal scope map for non-http request scopes. The {@link #REQUEST}
+   * scope falls back to this scope map if no http request is available, and
+   * requires {@link #scopeRequest} to be called as an alertnative.
+   */
+  private static final ThreadLocal<Map<String, Object>> requestScopeContext
+      = new ThreadLocal<Map<String, Object>>();
+
   /** A sentinel attribute value representing null. */
   enum NullObject { INSTANCE }
 
@@ -233,12 +247,59 @@
   }
 
   /**
-   * A threadlocal scope map for non-http request scopes. The {@link #REQUEST}
-   * scope falls back to this scope map if no http request is available, and
-   * requires {@link #scopeRequest} to be called as an alertnative.
+   * Returns true if {@code binding} is request-scoped. If the binding is a
+   * {@link com.google.inject.spi.LinkedKeyBinding linked key binding} and
+   * belongs to an injector (i. e. it was retrieved via
+   * {@link Injector#getBinding Injector.getBinding()}), then this method will
+   * also return true if the target binding is request-scoped.
    */
-  private static final ThreadLocal<Map<String, Object>> requestScopeContext
-      = new ThreadLocal<Map<String, Object>>();
+  public static boolean isRequestScoped(Binding<?> binding) {
+    do {
+      boolean requestScoped = binding.acceptScopingVisitor(new BindingScopingVisitor<Boolean>() {
+        @Override
+        public Boolean visitNoScoping() {
+          return false;
+        }
+
+        @Override
+        public Boolean visitScopeAnnotation(Class<? extends Annotation> scopeAnnotation) {
+          return scopeAnnotation == RequestScoped.class;
+        }
+
+        @Override
+        public Boolean visitScope(Scope scope) {
+          return scope == ServletScopes.REQUEST;
+        }
+
+        @Override
+        public Boolean visitEagerSingleton() {
+          return false;
+        }
+      });
+
+      if (requestScoped) {
+        return true;
+      }
+
+      if (binding instanceof LinkedBindingImpl) {
+        LinkedBindingImpl<?> linkedBinding = (LinkedBindingImpl<?>) binding;
+        Injector injector = linkedBinding.getInjector();
+        if (injector != null) {
+          binding = injector.getBinding(linkedBinding.getLinkedKey());
+          continue;
+        }
+      } else if (binding instanceof ExposedBinding) {
+        ExposedBinding<?> exposedBinding = (ExposedBinding<?>) binding;
+        Injector injector = exposedBinding.getPrivateElements().getInjector();
+        if (injector != null) {
+          binding = injector.getBinding(exposedBinding.getKey());
+          continue;
+        }
+      }
+
+      return false;
+    } while (true);
+  }
 
   /**
    * Scopes the given callable inside a request scope. This is not the same
diff --git a/extensions/servlet/test/com/google/inject/servlet/ServletScopesTest.java b/extensions/servlet/test/com/google/inject/servlet/ServletScopesTest.java
new file mode 100644
index 0000000..0ad40e3
--- /dev/null
+++ b/extensions/servlet/test/com/google/inject/servlet/ServletScopesTest.java
@@ -0,0 +1,203 @@
+/**
+ * Copyright (C) 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.inject.servlet;
+
+import static com.google.inject.name.Names.named;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.inject.AbstractModule;
+import com.google.inject.Binding;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.Module;
+import com.google.inject.PrivateModule;
+import com.google.inject.Provides;
+import com.google.inject.ScopeAnnotation;
+import com.google.inject.Scopes;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
+import com.google.inject.spi.Element;
+import com.google.inject.spi.Elements;
+import com.google.inject.spi.PrivateElements;
+import com.google.inject.util.Providers;
+
+import junit.framework.TestCase;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Tests for {@link ServletScopes}.
+ *
+ * @author forster@google.com (Mike Forster)
+ */
+public class ServletScopesTest extends TestCase {
+  public void testIsRequestScopedPositive() {
+    final Key<String> a = Key.get(String.class, named("A"));
+    final Key<String> b = Key.get(String.class, named("B"));
+    final Key<String> c = Key.get(String.class, named("C"));
+    final Key<String> d = Key.get(String.class, named("D"));
+    final Key<Object> e = Key.get(Object.class, named("E"));
+    final Key<String> f = Key.get(String.class, named("F"));
+    final Key<String> g = Key.get(String.class, named("G"));
+
+    Module requestScopedBindings = new AbstractModule() {
+      @Override
+      protected void configure() {
+        bind(a).to(b);
+        bind(b).to(c);
+        bind(c).toProvider(Providers.of("c")).in(ServletScopes.REQUEST);
+        bind(d).toProvider(Providers.of("d")).in(RequestScoped.class);
+        bind(e).to(AnnotatedRequestScopedClass.class);
+        install(new PrivateModule() {
+          @Override
+          protected void configure() {
+            bind(f).toProvider(Providers.of("f")).in(RequestScoped.class);
+            expose(f);
+          }
+        });
+      }
+
+      @Provides
+      @Named("G")
+      @RequestScoped
+      String provideG() {
+        return "g";
+      }
+    };
+
+    @SuppressWarnings("unchecked") // we know the module contains only bindings
+    List<Element> moduleBindings = Elements.getElements(requestScopedBindings);
+    ImmutableMap<Key<?>, Binding<?>> map = indexBindings(moduleBindings);
+    // linked bindings are not followed by modules
+    assertFalse(ServletScopes.isRequestScoped(map.get(a)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(b)));
+    assertTrue(ServletScopes.isRequestScoped(map.get(c)));
+    assertTrue(ServletScopes.isRequestScoped(map.get(d)));
+    // annotated classes are not followed by modules
+    assertFalse(ServletScopes.isRequestScoped(map.get(e)));
+    assertTrue(ServletScopes.isRequestScoped(map.get(f)));
+    assertTrue(ServletScopes.isRequestScoped(map.get(g)));
+
+    Injector injector = Guice.createInjector(requestScopedBindings, new ServletModule());
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(a)));
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(b)));
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(c)));
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(d)));
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(e)));
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(f)));
+    assertTrue(ServletScopes.isRequestScoped(injector.getBinding(g)));
+  }
+
+  public void testIsRequestScopedNegative() {
+    final Key<String> a = Key.get(String.class, named("A"));
+    final Key<String> b = Key.get(String.class, named("B"));
+    final Key<String> c = Key.get(String.class, named("C"));
+    final Key<String> d = Key.get(String.class, named("D"));
+    final Key<String> e = Key.get(String.class, named("E"));
+    final Key<String> f = Key.get(String.class, named("F"));
+    final Key<String> g = Key.get(String.class, named("G"));
+    final Key<String> h = Key.get(String.class, named("H"));
+    final Key<String> i = Key.get(String.class, named("I"));
+    final Key<String> j = Key.get(String.class, named("J"));
+
+    Module requestScopedBindings = new AbstractModule() {
+      @Override
+      protected void configure() {
+        bind(a).to(b);
+        bind(b).to(c);
+        bind(c).toProvider(Providers.of("c")).in(Scopes.NO_SCOPE);
+        bind(d).toInstance("d");
+        bind(e).toProvider(Providers.of("e")).asEagerSingleton();
+        bind(f).toProvider(Providers.of("f")).in(Scopes.SINGLETON);
+        bind(g).toProvider(Providers.of("g")).in(Singleton.class);
+        bind(h).toProvider(Providers.of("h")).in(CustomScoped.class);
+        bindScope(CustomScoped.class, Scopes.NO_SCOPE);
+        install(new PrivateModule() {
+          @Override
+          protected void configure() {
+            bind(i).toProvider(Providers.of("i")).in(CustomScoped.class);
+            expose(i);
+          }
+        });
+      }
+
+      @Provides
+      @Named("J")
+      @CustomScoped
+      String provideJ() {
+        return "j";
+      }
+    };
+
+    @SuppressWarnings("unchecked") // we know the module contains only bindings
+    List<Element> moduleBindings = Elements.getElements(requestScopedBindings);
+    ImmutableMap<Key<?>, Binding<?>> map = indexBindings(moduleBindings);
+    assertFalse(ServletScopes.isRequestScoped(map.get(a)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(b)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(c)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(d)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(e)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(f)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(g)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(h)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(i)));
+    assertFalse(ServletScopes.isRequestScoped(map.get(j)));
+
+    Injector injector = Guice.createInjector(requestScopedBindings);
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(a)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(b)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(c)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(d)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(e)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(f)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(g)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(h)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(i)));
+    assertFalse(ServletScopes.isRequestScoped(injector.getBinding(j)));
+  }
+
+  @RequestScoped
+  static class AnnotatedRequestScopedClass {}
+
+  @Target({ ElementType.TYPE, ElementType.METHOD })
+  @Retention(RUNTIME)
+  @ScopeAnnotation
+  private @interface CustomScoped {}
+
+  private ImmutableMap<Key<?>, Binding<?>> indexBindings(Iterable<Element> elements) {
+    ImmutableMap.Builder<Key<?>, Binding<?>> builder = ImmutableMap.builder();
+    for (Element element : elements) {
+      if (element instanceof Binding) {
+        Binding<?> binding = (Binding<?>) element;
+        builder.put(binding.getKey(), binding);
+      } else if (element instanceof PrivateElements) {
+        PrivateElements privateElements = (PrivateElements) element;
+        Map<Key<?>, Binding<?>> privateBindings = indexBindings(privateElements.getElements());
+        for (Key<?> exposed : privateElements.getExposedKeys()) {
+          builder.put(exposed, privateBindings.get(exposed));
+        }
+      }
+    }
+    return builder.build();
+  }
+}