diff --git a/core/lib/Drupal/Component/Plugin/Context/Context.php b/core/lib/Drupal/Component/Plugin/Context/Context.php
new file mode 100644
index 0000000..b117a72
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Context/Context.php
@@ -0,0 +1,87 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\Plugin\Context\Context.
+ */
+
+namespace Drupal\Component\Plugin\Context;
+
+use Drupal\Component\Plugin\Exception\ContextException;
+use Symfony\Component\Validator\Constraints\Type;
+use Symfony\Component\Validator\Validation;
+
+/**
+ * A generic context class for wrapping data a plugin needs to operate.
+ */
+class Context implements ContextInterface {
+
+  /**
+   * The value of the context.
+   *
+   * @var mixed
+   */
+  protected $contextValue;
+
+  /**
+   * The definition to which a context must conform.
+   *
+   * @var array
+   */
+  protected $contextDefinition;
+
+  /**
+   * Sets the contextDefinition for us without needing to call the setter.
+   */
+  public function __construct(array $context_definition) {
+    $this->contextDefinition = $context_definition;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::setContextValue().
+   */
+  public function setContextValue($value) {
+    $this->contextValue = $value;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::getContextValue().
+   */
+  public function getContextValue() {
+    return $this->contextValue;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::setContextDefinition().
+   */
+  public function setContextDefinition(array $context_definition) {
+    $this->contextDefinition = $context_definition;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::getContextDefinition().
+   */
+  public function getContextDefinition() {
+    return $this->contextDefinition;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::getConstraints().
+   */
+  public function getConstraints() {
+    if (empty($this->contextDefinition['class'])) {
+      throw new ContextException("An error was encountered while trying to validate the context.");
+    }
+    return array(new Type($this->contextDefinition['class']));
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::validate().
+   */
+  public function validate() {
+    $validator = Validation::createValidatorBuilder()
+      ->getValidator();
+    return $validator->validateValue($this->getContextValue(), $this->getConstraints());
+  }
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/Context/ContextInterface.php b/core/lib/Drupal/Component/Plugin/Context/ContextInterface.php
new file mode 100644
index 0000000..512605a
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Context/ContextInterface.php
@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\Plugin\Context\ContextInterface.
+ */
+
+namespace Drupal\Component\Plugin\Context;
+
+use Drupal\Component\Plugin\Exception\ContextException;
+
+/**
+ * A generic context interface for wrapping data a plugin needs to operate.
+ */
+interface ContextInterface {
+
+  /**
+   * Sets the context value.
+   *
+   * @param mixed $value
+   *   The value of this context, generally an object based upon the class
+   *   matching the definition passed to setContextDefinition().
+   */
+  public function setContextValue($value);
+
+  /**
+   * Gets the context value.
+   *
+   * @return mixed
+   *   The currently set context value within this class.
+   */
+  public function getContextValue();
+
+  /**
+   * Sets the definition that the context must conform to.
+   *
+   * @param array $contextDefinition
+   *   A defining characteristic representation of the context against which
+   *   that context can be validated. This is typically an array having a
+   *   class name set under the 'class' key, but it could be extended to support
+   *   other notations.
+   */
+  public function setContextDefinition(array $contextDefinition);
+
+  /**
+   * Gets the provided definition that the context must conform to.
+   *
+   * @return array
+   *   The defining characteristic representation of the context.
+   */
+  public function getContextDefinition();
+
+  /**
+   * Gets a list of validation constraints.
+   *
+   * @return array
+   *   Array of constraints, each being an instance of
+   *   \Symfony\Component\Validator\Constraint.
+   */
+  public function getConstraints();
+
+  /**
+   * Validates the set context value.
+   *
+   * @return \Symfony\Component\Validator\ConstraintViolationListInterface
+   *   A list of constraint violations. If the list is empty, validation
+   *   succeeded.
+   */
+  public function validate();
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/ContextAwarePluginBase.php b/core/lib/Drupal/Component/Plugin/ContextAwarePluginBase.php
new file mode 100644
index 0000000..c6ffc3d
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/ContextAwarePluginBase.php
@@ -0,0 +1,136 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\Plugin\ContextAwarePluginBase
+ */
+
+namespace Drupal\Component\Plugin;
+
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Component\Plugin\Context\Context;
+use Symfony\Component\Validator\ConstraintViolationList;
+
+/**
+ * Base class for plugins that are context aware.
+ */
+abstract class ContextAwarePluginBase extends PluginBase implements ContextAwarePluginInterface {
+
+  /**
+   * The data objects representing the context of this plugin.
+   *
+   * @var array
+   */
+  protected $context;
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::getContextDefinitions().
+   */
+  public function getContextDefinitions() {
+    $definition = $this->getDefinition();
+    return !empty($definition['context']) ? $definition['context'] : NULL;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::getContextDefinition().
+   */
+  public function getContextDefinition($key) {
+    $definition = $this->getDefinition();
+    if (empty($definition['context'][$key])) {
+      throw new PluginException("The $key context is not a valid context.");
+    }
+    return $definition['context'][$key];
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::getContexts().
+   */
+  public function getContexts() {
+    $definitions = $this->getContextDefinitions();
+    // If there are no contexts defined by the plugin, return an empty array.
+    if (empty($definitions)) {
+      return array();
+    }
+    if (empty($this->context)) {
+      throw new PluginException("There are no set contexts.");
+    }
+    $contexts = array();
+    foreach (array_keys($definitions) as $key) {
+      if (empty($this->context[$key])) {
+        throw new PluginException("The $key context is not yet set.");
+      }
+      $contexts[$key] = $this->context[$key];
+    }
+    return $contexts;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::getContext().
+   */
+  public function getContext($key) {
+    // Check for a valid context definition.
+    $this->getContextDefinition($key);
+    // Check for a valid context value.
+    if (empty($this->context[$key])) {
+      throw new PluginException("The $key context is not yet set.");
+    }
+
+    return $this->context[$key];
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::getContextValues().
+   */
+  public function getContextValues() {
+    $definitions = (array) $this->getContextDefinitions();
+    $values = array();
+    foreach ($definitions as $key => $definition) {
+      $values[$key] = isset($this->context[$key]) ? $this->context[$key]->getContextValue() : NULL;
+    }
+    return $values;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::getContextValue().
+   */
+  public function getContextValue($key) {
+    return $this->getContext($key)->getContextValue();
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\ContextAwarePluginInterface::setContextValue().
+   */
+  public function setContextValue($key, $value) {
+    $context_definition = $this->getContextDefinition($key);
+    $this->context[$key] = new Context($context_definition);
+    $this->context[$key]->setContextValue($value);
+
+    // Verify the provided value validates.
+    $violations = $this->context[$key]->validate();
+    if (count($violations) > 0) {
+      throw new PluginException("The provided context value does not pass validation.");
+    }
+    return $this;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::valdidate().
+   */
+  public function validate() {
+    $violations = new ConstraintViolationList();
+    // @todo: Implement symfony validator API to let the validator traverse
+    // and set property paths accordingly.
+
+    if ($definitions = $this->getContextDefinitions()) {
+      foreach ($definitions as $key => $definition) {
+        // Validate any set values.
+        if (isset($this->context[$key])) {
+          $violations->addAll($this->context[$key]->validate());
+        }
+        // @todo: If no value is set, make sure any mapping is validated.
+      }
+    }
+    return $violations;
+  }
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/ContextAwarePluginInterface.php b/core/lib/Drupal/Component/Plugin/ContextAwarePluginInterface.php
new file mode 100644
index 0000000..086a25f
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/ContextAwarePluginInterface.php
@@ -0,0 +1,116 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\Plugin\ContextAwarePluginInterface.
+ */
+
+namespace Drupal\Component\Plugin;
+
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Component\Plugin\Context\Context;
+
+/**
+ * Interface for defining context aware plugins.
+ */
+interface ContextAwarePluginInterface extends PluginInspectionInterface {
+
+  /**
+   * Gets the context definitions of the plugin.
+   *
+   * @return array|null
+   *   The context definitions if set, otherwise NULL.
+   */
+  public function getContextDefinitions();
+
+  /**
+   * Gets the a specific context definition of the plugin.
+   *
+   * @param string $key
+   *   The name of the context in the plugin definition.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   *   If the requested definition is not set.
+   *
+   * @return array
+   *   The definition against which the context value must validate.
+   */
+  public function getContextDefinition($key);
+
+  /**
+   * Gets the defined contexts.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   *   If contexts are defined but not set.
+   *
+   * @return array
+   *   The set context objects.
+   */
+  public function getContexts();
+
+  /**
+   * Gets a defined context.
+   *
+   * @param string $key
+   *   The name of the context in the plugin configuration. This string is
+   *   usually identical to the representative string in the plugin definition.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   *   If the requested context is not set.
+   *
+   * @return \Drupal\Component\Plugin\Context\ContextInterface
+   *   The context object.
+   */
+  public function getContext($key);
+
+  /**
+   * Gets the values for all defined contexts.
+   *
+   * @return array
+   *   An array of set context values, keyed by context key. If a context is
+   *   unset its value is returned as NULL.
+   */
+  public function getContextValues();
+
+  /**
+   * Gets the value for a defined context.
+   *
+   * @param string $key
+   *   The name of the context in the plugin configuration. This string is
+   *   usually identical to the representative string in the plugin definition.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   *   If the requested context is not set.
+   *
+   * @return mixed
+   *   The currently set context value.
+   */
+  public function getContextValue($key);
+
+  /**
+   * Sets the value for a defined context.
+   *
+   * @param string $key
+   *   The name of the context in the plugin definition.
+   * @param mixed $value
+   *   The variable to set the context to. This should validate against the
+   *   provided context definition.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginException
+   *   If the value does not pass validation.
+   *
+   * @return \Drupal\Component\Plugin\ContextAwarePluginInterface.
+   *   A context aware plugin object for chaining.
+   */
+  public function setContextValue($key, $value);
+
+  /**
+   * Validates the set values for the defined contexts.
+   *
+   * @return \Symfony\Component\Validator\ConstraintViolationListInterface
+   *   A list of constraint violations. If the list is empty, validation
+   *   succeeded.
+   */
+  public function validate();
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/Exception/ContextException.php b/core/lib/Drupal/Component/Plugin/Exception/ContextException.php
new file mode 100644
index 0000000..0618251
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Exception/ContextException.php
@@ -0,0 +1,15 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\Plugin\Exception\ContextException.
+ */
+
+namespace Drupal\Component\Plugin\Exception;
+
+use Exception;
+
+/**
+ * An exception class to be thrown for context plugin exceptions.
+ */
+class ContextException extends Exception implements ExceptionInterface { }
diff --git a/core/lib/Drupal/Core/CoreBundle.php b/core/lib/Drupal/Core/CoreBundle.php
index 035f282..8714fac 100644
--- a/core/lib/Drupal/Core/CoreBundle.php
+++ b/core/lib/Drupal/Core/CoreBundle.php
@@ -270,6 +270,8 @@ public function build(ContainerBuilder $container) {
     $container->register('flood', 'Drupal\Core\Flood\DatabaseBackend')
       ->addArgument(new Reference('database'));
 
+    $container->register('plugin.manager.processor', 'Drupal\Core\Processor\ProcessorManager');
+
     $container->addCompilerPass(new RegisterMatchersPass());
     $container->addCompilerPass(new RegisterRouteFiltersPass());
     // Add a compiler pass for registering event subscribers.
diff --git a/core/lib/Drupal/Core/Executable/ExecutableException.php b/core/lib/Drupal/Core/Executable/ExecutableException.php
new file mode 100644
index 0000000..7ea5d98
--- /dev/null
+++ b/core/lib/Drupal/Core/Executable/ExecutableException.php
@@ -0,0 +1,17 @@
+<?php
+
+/**
+ * @file
+ * Contains of \Drupal\Core\Executable\ExecutableException.
+ */
+
+namespace Drupal\Core\Executable;
+
+use Exception;
+use Drupal\Component\Plugin\Exception\ExceptionInterface;
+
+/**
+ * Generic action exception class.
+ */
+class ExecutableException extends Exception implements ExceptionInterface {
+}
diff --git a/core/lib/Drupal/Core/Executable/ExecutableInterface.php b/core/lib/Drupal/Core/Executable/ExecutableInterface.php
new file mode 100644
index 0000000..4f0605d
--- /dev/null
+++ b/core/lib/Drupal/Core/Executable/ExecutableInterface.php
@@ -0,0 +1,94 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Executable\ExecutableInterface.
+ */
+
+namespace Drupal\Core\Executable;
+
+use Drupal\Component\Plugin\ContextAwarePluginInterface;
+use Drupal\Core\Executable\ExecutableManagerInterface;
+use Drupal\Core\Processor\ProcessorManager;
+
+
+/**
+ * An interface for executable and processable plugins.
+ */
+interface ExecutableInterface extends ContextAwarePluginInterface {
+
+  /**
+   * Sets the processor plugin manager.
+   */
+  public function setProcessorManager(ProcessorManager $processorManager);
+
+  /**
+   * Sets the processor plugin.
+   */
+  public function setProcessor($plugin_id, array $configuration);
+
+  /**
+   * Gets an array of processors.
+   */
+  public function getProcessors();
+
+  /**
+   * Sets the executable manager of this plugin.
+   *
+   * @param \Drupal\Core\Executable\ExecutableManagerInterface $executableManager
+   */
+  public function setExecutableManager(ExecutableManagerInterface $executableManager);
+
+  /**
+   * Gets the executable manager of this plugin.
+   *
+   * @return \Drupal\Core\Executable\ExecutableManagerInterface
+   *   The executable manager.
+   */
+  public function getExecutableManager();
+
+  /**
+   * Executes the plugin.
+   *
+   * @throws \Drupal\Core\Executable\ExecutableException
+   *   If the plugin could not be executed.
+   */
+  public function execute();
+
+  /**
+   * Constructs the executable's configuration form.
+   *
+   * This method allows base implementations to add a generic configuration
+   * form for the plugin.
+   *
+   * @param array $form
+   *   The form definition array for the configuration form.
+   * @param array $form_state
+   *   An array containing the current state of the configuration form.
+   *
+   * @return array $form
+   *   The renderable form array representing the entire configuration form.
+   *
+   * @see \Drupal\Core\Executable\ExecutableInterface::extractFormValues()
+   * @see \Drupal\Core\Executable\ExecutableInterface::validate()
+   */
+  public function form($form, &$form_state);
+
+  /**
+   * Extracts configuration from submitted form values.
+   *
+   * @param array $form
+   *   The form definition array for the configuration form.
+   * @param array $form_state
+   *   An array containing the current state of the configuration form.
+   *
+   * @see \Drupal\Core\Executable\ExecutableInterface::form()
+   * @see \Drupal\Core\Executable\ExecutableInterface::validate()
+   */
+  public function extractFormValues($form, &$form_state);
+
+  /**
+   * Provides a human readable summary of the executable's configuration.
+   */
+  public function summary();
+}
diff --git a/core/lib/Drupal/Core/Executable/ExecutableManagerInterface.php b/core/lib/Drupal/Core/Executable/ExecutableManagerInterface.php
new file mode 100644
index 0000000..2ea51f6
--- /dev/null
+++ b/core/lib/Drupal/Core/Executable/ExecutableManagerInterface.php
@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Executable\ExecutableManagerInterface.
+ */
+
+namespace Drupal\Core\Executable;
+
+use Drupal\Component\Plugin\PluginManagerInterface;
+
+/**
+ * An interface for managers of executable plugins.
+ */
+interface ExecutableManagerInterface extends PluginManagerInterface {
+
+  /**
+   * Executes an executable plugin.
+   *
+   * @param \Drupal\Core\Executable\ExecutableInterface $plugin
+   *   An executable plugin instance managed by the implementing manager.
+   *
+   * @throws \Drupal\Core\Executable\ExecutableException
+   *   If the plugin could not be executed.
+   *
+   * @return mixed
+   *   The returned data varies by plugin implementation, e.g. conditions return
+   *   the the boolean evaluation result.
+   */
+  public function execute(\Drupal\Core\Executable\ExecutableInterface $plugin);
+
+}
diff --git a/core/lib/Drupal/Core/Executable/ExecutablePluginBase.php b/core/lib/Drupal/Core/Executable/ExecutablePluginBase.php
new file mode 100644
index 0000000..2dba995
--- /dev/null
+++ b/core/lib/Drupal/Core/Executable/ExecutablePluginBase.php
@@ -0,0 +1,118 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Executable\ExecutablePluginBase.
+ */
+
+namespace Drupal\Core\Executable;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+use Drupal\Core\Executable\ExecutableManagerInterface;
+use Drupal\Core\Plugin\ContextAwarePluginBase;
+use Drupal\Core\Processor\ProcessorManager;
+
+/**
+ * Provides the basic architecture for executable and processable plugins.
+ */
+abstract class ExecutablePluginBase extends ContextAwarePluginBase implements ExecutableInterface {
+
+  /**
+   * The plugin manager for processor plugins.
+   *
+   * @var ProcessorManager object
+   */
+  protected $processorManager;
+
+  /**
+   * The executable manager of this plugin.
+   *
+   * @var ExecutableManagerInterface
+   */
+  protected $executableManager;
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::setProcessorManager().
+   */
+  public function setProcessorManager(ProcessorManager $processorManager) {
+    $this->processorManager = $processorManager;
+    return $this;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::setProcessor().
+   */
+  public function setProcessor($plugin_id, array $configuration) {
+    // @todo Do we want to check this before actually assigning?
+    $this->configuration['processors'][] = $this->processorManager->createInstance($plugin_id, $configuration);
+    return $this;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::getProcessor().
+   */
+  public function getProcessors() {
+    return $this->configuration['processors'];
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::setExecutableManager().
+   */
+  public function setExecutableManager(ExecutableManagerInterface $executableManager) {
+    $this->executableManager = $executableManager;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::getExecutableManager().
+   */
+  public function getExecutableManager() {
+    return $this->executableManager;
+  }
+
+  /**
+   * Gets all configuration values.
+   *
+   * @see \Drupal\Component\Plugin\PluginBase::$configuration
+   *
+   * @return array
+   */
+  public function getConfig() {
+    return $this->configuration;
+  }
+
+  /**
+   * Sets a particular value in the block settings.
+   *
+   * @param string $key
+   *   The key of PluginBase::$configuration to set.
+   * @param mixed $value
+   *   The value to set for the provided key.
+   *
+   * @todo This doesn't belong here. Move this into a new base class in
+   *   http://drupal.org/node/1764380.
+   * @todo This does not set a value in config(), so the name is confusing.
+   *
+   * @see \Drupal\Component\Plugin\PluginBase::$configuration
+   */
+  public function setConfig($key, $value) {
+    $this->configuration[$key] = $value;
+    return $this;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::form().
+   */
+  public function form($form, &$form_state) {
+    // @todo add context definition parsing and provide select elements for
+    // fulfilling contexts from some source.
+    return $form;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableInterface::extractFormValues().
+   */
+  public function extractFormValues($form, &$form_state) {
+    // Nothing to extract by default.
+  }
+}
+
diff --git a/core/lib/Drupal/Core/Plugin/Context/Context.php b/core/lib/Drupal/Core/Plugin/Context/Context.php
new file mode 100644
index 0000000..3eb195d
--- /dev/null
+++ b/core/lib/Drupal/Core/Plugin/Context/Context.php
@@ -0,0 +1,100 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Plugin\Context\Context.
+ */
+
+namespace Drupal\Core\Plugin\Context;
+
+use Drupal\Component\Plugin\Context\Context as ComponentContext;
+use Drupal\Core\TypedData\ComplexDataInterface;
+use Drupal\Core\TypedData\ListInterface;
+use Drupal\Core\TypedData\TypedDataInterface;
+use Drupal\Core\Validation\DrupalTranslator;
+use Symfony\Component\Validator\Validation;
+
+/**
+ * A Drupal specific context wrapper class.
+ *
+ * The validate method is specifically overridden in order to support typed
+ * data definitions instead of just class names in the contextual definitions
+ * of plugins that extend ContextualPluginBase.
+ */
+class Context extends ComponentContext {
+
+  /**
+   * Overrides \Drupal\Component\Plugin\Context\Context::getContextValue().
+   */
+  public function getContextValue() {
+    $typed_value = parent::getContextValue();
+    // If the typed data is complex, pass it on as typed data. Else pass on its
+    // plain value, such that e.g. a string will be directly returned as PHP
+    // string.
+    $is_complex = $typed_value instanceof ComplexDataInterface;
+    if (!$is_complex && $typed_value instanceof ListInterface) {
+      $is_complex = $typed_value[0] instanceof ComplexDataInterface;
+    }
+    // @todo We won't need the getType == entity check once #1868004 lands.
+    if ($typed_value instanceof TypedDataInterface && (!$is_complex || $typed_value->getType() == 'entity')) {
+      return $typed_value->getValue();
+    }
+    return $typed_value;
+  }
+
+  /**
+   * Implements \Drupal\Component\Plugin\Context\ContextInterface::setContextValue().
+   */
+  public function setContextValue($value) {
+    // Make sure the value set is a typed data object.
+    if (!empty($this->contextDefinition['type']) && !$value instanceof TypedDataInterface) {
+      $value = typed_data()->create($this->contextDefinition, $value);
+    }
+    parent::setContextValue($value);
+  }
+
+  /**
+   * Gets the context value as typed data object.
+   *
+   * parent::getContextValue() does not do all the processing required to
+   * return plain value of a TypedData object. This class overrides that method
+   * to return the appropriate values from TypedData objects, but the object
+   * itself can be useful as well, so this method is provided to allow for
+   * access to the TypedData object. Since parent::getContextValue() already
+   * does all the processing we need, we simply proxy to it here.
+   *
+   * @return \Drupal\Core\TypedData\TypedDataInterface
+   */
+  public function getTypedContext() {
+    return parent::getContextValue();
+  }
+
+  /**
+   * Overrides \Drupal\Component\Plugin\Context\Context::getConstraints().
+   */
+  public function getConstraints() {
+    if (!empty($this->contextDefinition['type'])) {
+      // If we do have typed data, leverage it for getting constraints.
+      return $this->getTypedContext()->getConstraints();
+    }
+    return parent::getConstraints();
+  }
+
+  /**
+   * Overrides \Drupal\Component\Plugin\Context\Context::getConstraints().
+   */
+  public function validate() {
+    $validator = Validation::createValidatorBuilder()
+      ->setTranslator(new DrupalTranslator())
+      ->getValidator();
+
+    // @todo We won't need to special case "entity" here once #1868004 lands.
+    if (!empty($this->contextDefinition['type']) && $this->contextDefinition['type'] == 'entity') {
+      $value = $this->getTypedContext();
+    }
+    else {
+      $value = $this->getContextValue();
+    }
+    return $validator->validateValue($value, $this->getConstraints());
+  }
+}
diff --git a/core/lib/Drupal/Core/Plugin/ContextAwarePluginBase.php b/core/lib/Drupal/Core/Plugin/ContextAwarePluginBase.php
new file mode 100644
index 0000000..e4daeb1
--- /dev/null
+++ b/core/lib/Drupal/Core/Plugin/ContextAwarePluginBase.php
@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Plugin\ContextAwarePluginBase
+ */
+
+namespace Drupal\Core\Plugin;
+
+use Drupal\Component\Plugin\ContextAwarePluginBase as PluginBase;
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Core\Plugin\Context\Context;
+
+/**
+ * Drupal specific class for plugins that use context.
+ *
+ * This class specifically overrides setContextValue to use the core version of
+ * the Context class. This code is exactly the same as what is in Component
+ * ContextAwarePluginBase but it is using a different Context class.
+ */
+abstract class ContextAwarePluginBase extends PluginBase {
+
+  /**
+   * Override of \Drupal\Component\Plugin\ContextAwarePluginBase::setContextValue().
+   */
+  public function setContextValue($key, $value) {
+    $context_definition = $this->getContextDefinition($key);
+    $this->context[$key] = new Context($context_definition);
+    $this->context[$key]->setContextValue($value);
+
+    // Verify the provided value validates.
+    if ($this->context[$key]->validate()->count() > 0) {
+      throw new PluginException("The provided context value does not pass validation.");
+    }
+    return $this;
+  }
+
+}
diff --git a/core/lib/Drupal/Core/Plugin/Validation/Constraint/EntityTypeConstraintValidator.php b/core/lib/Drupal/Core/Plugin/Validation/Constraint/EntityTypeConstraintValidator.php
index 21b2ac2..1e1aba4 100644
--- a/core/lib/Drupal/Core/Plugin/Validation/Constraint/EntityTypeConstraintValidator.php
+++ b/core/lib/Drupal/Core/Plugin/Validation/Constraint/EntityTypeConstraintValidator.php
@@ -22,7 +22,7 @@ public function validate($typed_data, Constraint $constraint) {
     $entity = isset($typed_data) ? $typed_data->getValue() : FALSE;
 
     if (!empty($entity) && $entity->entityType() != $constraint->type) {
-      $this->context->addViolation($constraint->message, array('%type', $constraint->type));
+      $this->context->addViolation($constraint->message, array('%type' => $constraint->type));
     }
   }
 }
diff --git a/core/lib/Drupal/Core/Processor/ProcessorInterface.php b/core/lib/Drupal/Core/Processor/ProcessorInterface.php
new file mode 100644
index 0000000..a3e15e7
--- /dev/null
+++ b/core/lib/Drupal/Core/Processor/ProcessorInterface.php
@@ -0,0 +1,15 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\Core\Processor\ProcessorInterface.
+ */
+
+namespace Drupal\Core\Processor;
+
+/**
+ * @todo.
+ */
+interface ProcessorInterface {
+}
+
diff --git a/core/lib/Drupal/Core/Processor/ProcessorManager.php b/core/lib/Drupal/Core/Processor/ProcessorManager.php
new file mode 100644
index 0000000..8706f3f
--- /dev/null
+++ b/core/lib/Drupal/Core/Processor/ProcessorManager.php
@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Processor\ProcessorManager.
+ */
+
+namespace Drupal\Core\Processor;
+
+use Drupal\Component\Plugin\PluginManagerBase;
+use Drupal\Component\Plugin\Factory\DefaultFactory;
+use Drupal\Component\Plugin\Discovery\ProcessDecorator;
+use Drupal\Core\Plugin\Discovery\AlterDecorator;
+use Drupal\Core\Plugin\Discovery\AnnotatedClassDiscovery;
+use Drupal\Core\Plugin\Discovery\CacheDecorator;
+
+/**
+ * @todo.
+ */
+class ProcessorManager extends PluginManagerBase {
+
+  /**
+   * Constructs aa ProcessorManager object.
+   */
+  public function __construct() {
+    $this->discovery = new AnnotatedClassDiscovery('Core', 'Processor');
+    $this->discovery = new AlterDecorator($this->discovery, 'processor');
+    $this->discovery = new ProcessDecorator($this->discovery, array($this, 'processDefinition'));
+    $this->discovery = new CacheDecorator($this->discovery, 'processor:' . language(LANGUAGE_TYPE_INTERFACE)->langcode);
+
+    $this->factory = new DefaultFactory($this);
+  }
+
+}
+
diff --git a/core/lib/Drupal/Core/TypedData/Type/Any.php b/core/lib/Drupal/Core/TypedData/Type/Any.php
new file mode 100644
index 0000000..21afa99
--- /dev/null
+++ b/core/lib/Drupal/Core/TypedData/Type/Any.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\TypedData\Type\Any.
+ */
+
+namespace Drupal\Core\TypedData\Type;
+
+use Drupal\Core\TypedData\TypedData;
+
+/**
+ * The "any" data type.
+ *
+ * The "any" data type does not implement a list or complex data interface, nor
+ * is it mappable to any primitive type. Thus, it may contain any PHP data for
+ * which no further metadata is available.
+ */
+class Any extends TypedData {
+
+  /**
+   * The data value.
+   *
+   * @var mixed
+   */
+  protected $value;
+}
diff --git a/core/modules/condition/condition.info b/core/modules/condition/condition.info
new file mode 100644
index 0000000..52d7d2a
--- /dev/null
+++ b/core/modules/condition/condition.info
@@ -0,0 +1,6 @@
+name = Conditions
+description = Perform evaluations of various information to yield TRUE/FALSE statements.
+package = Core
+version = VERSION
+core = 8.x
+configure = admin/config/system/conditions
diff --git a/core/modules/condition/condition.module b/core/modules/condition/condition.module
new file mode 100644
index 0000000..d6ed5b2
--- /dev/null
+++ b/core/modules/condition/condition.module
@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * Creates and configures a new condition plugin instance.
+ *
+ * @param $plugin_id
+ *   The id of the plugin to instantiate.
+ * @param $options
+ *   An array of options to pass into the plugin instance for configuration
+ *   purposes.
+ *
+ * @return Drupal\condition\Plugin\ConditionInterface object
+ *   A new condition plugin instance.
+ *
+ * @see Drupal\Component\Plugin\PluginManagerBase
+ * @see Drupal\condition\Plugin\Type\ConditionManager
+ */
+function condition($plugin_id, $options = array()) {
+  return drupal_container()->get('plugin.manager.condition')->createInstance($plugin_id, $options);
+}
diff --git a/core/modules/condition/lib/Drupal/condition/ConditionBundle.php b/core/modules/condition/lib/Drupal/condition/ConditionBundle.php
new file mode 100644
index 0000000..b41a3db
--- /dev/null
+++ b/core/modules/condition/lib/Drupal/condition/ConditionBundle.php
@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\condition\ConditionBundle.
+ */
+
+namespace Drupal\condition;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Provides the condition dependency injection container.
+ */
+class ConditionBundle extends Bundle {
+
+  /**
+   * Overrides \Symfony\Component\HttpKernel\Bundle\Bundle::build().
+   */
+  public function build(ContainerBuilder $container) {
+    // Register the ConditionManager class with the dependency injection
+    // container and pass a reference to the processor plugin manager.
+    $container->register('plugin.manager.condition', 'Drupal\condition\Plugin\Type\ConditionManager')->addArgument(new Reference('plugin.manager.processor'));
+  }
+
+}
diff --git a/core/modules/condition/lib/Drupal/condition/Plugin/ConditionInterface.php b/core/modules/condition/lib/Drupal/condition/Plugin/ConditionInterface.php
new file mode 100644
index 0000000..f393c47
--- /dev/null
+++ b/core/modules/condition/lib/Drupal/condition/Plugin/ConditionInterface.php
@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\condition\Plugin\ConditionInterface.
+ */
+
+namespace Drupal\condition\Plugin;
+
+use Drupal\Core\Executable\ExecutableInterface;
+
+/**
+ * An interface for condition plugins.
+ */
+interface ConditionInterface extends ExecutableInterface {
+
+  /**
+   * Sets whether the condition result should be negated.
+   *
+   * @param bool $boolean
+   *   Whether to negate the result of the condition.
+   *
+   * @return \Drupal\condition\Plugin\ConditionInterface.
+   *   The condition object for chaining.
+   */
+  public function setNegate($boolean);
+
+  /**
+   * Determines whether condition result will be negaeted.
+   *
+   * @return boolean
+   *   Whether the condition result will be negated.
+   */
+  public function isNegated();
+
+  /**
+   * Evaluate the condition and return TRUE or FALSE accordingly
+   *
+   * @return bool
+   */
+  public function evaluate();
+
+}
diff --git a/core/modules/condition/lib/Drupal/condition/Plugin/ConditionPluginBase.php b/core/modules/condition/lib/Drupal/condition/Plugin/ConditionPluginBase.php
new file mode 100644
index 0000000..907f382
--- /dev/null
+++ b/core/modules/condition/lib/Drupal/condition/Plugin/ConditionPluginBase.php
@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\condition\Plugin\ConditionPluginBase.
+ */
+
+namespace Drupal\condition\Plugin;
+
+use Drupal\Core\Executable\ExecutablePluginBase;
+
+/**
+ * Provides a basis for fulfilling contexts for condition plugins.
+ */
+abstract class ConditionPluginBase extends ExecutablePluginBase implements ConditionInterface {
+
+  /**
+   * Implements \Drupal\condition\Plugin\ConditionInterface::setNegate().
+   */
+  public function setNegate($boolean) {
+    $this->configuration['negate'] = $boolean;
+    return $this;
+  }
+
+  /**
+   * Implements \Drupal\condition\Plugin\ConditionInterface::isNegated().
+   */
+  public function isNegated() {
+    return !empty($this->configuration['negate']);
+  }
+
+  /**
+   * Implements \Drupal\condition\Plugin\ConditionInterface::form().
+   */
+  public function form($form, &$form_state) {
+    // @todo add context definition parsing and provide select elements for
+    // fulfilling contexts from some source.
+    $form['negate'] = array(
+      '#type' => 'checkbox',
+      '#title' => t('Negate the condition.'),
+      '#default_value' => isset($this->configuration['negate']) ? $this->configuration['negate'] : FALSE,
+    );
+    return $form;
+  }
+
+  /**
+   * Overrides ExecutablePluginBase::extractFormValues().
+   */
+  public function extractFormValues($form, &$form_state) {
+    $this->configuration['negate'] = $form_state['values']['negate'];
+  }
+
+  /**
+   * Implements ExecutablePluginBase::execute().
+   */
+  public function execute() {
+    return $this->executableManager->execute($this);
+  }
+
+}
diff --git a/core/modules/condition/lib/Drupal/condition/Plugin/Type/ConditionManager.php b/core/modules/condition/lib/Drupal/condition/Plugin/Type/ConditionManager.php
new file mode 100644
index 0000000..2879083
--- /dev/null
+++ b/core/modules/condition/lib/Drupal/condition/Plugin/Type/ConditionManager.php
@@ -0,0 +1,61 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\condition\Plugin\Type\ConditionManager.
+ */
+
+namespace Drupal\condition\Plugin\Type;
+
+use Drupal\Component\Plugin\PluginManagerBase;
+use Drupal\Component\Plugin\Factory\DefaultFactory;
+use Drupal\Core\Executable\ExecutableInterface;
+use Drupal\Core\Executable\ExecutableManagerInterface;
+use Drupal\Core\Plugin\Discovery\AlterDecorator;
+use Drupal\Core\Plugin\Discovery\AnnotatedClassDiscovery;
+use Drupal\Core\Plugin\Discovery\CacheDecorator;
+use Drupal\Core\Processor\ProcessorManager;
+
+/**
+ * A plugin manager for condition plugins.
+ */
+class ConditionManager extends PluginManagerBase implements ExecutableManagerInterface {
+
+  /**
+   * The plugin manager for processor plugins.
+   *
+   * @var ProcessorManager object
+   */
+  protected $processorManager;
+
+  /**
+   * Constructs a ConditionManager object.
+   */
+  public function __construct(ProcessorManager $process_manager) {
+    $this->processorManager = $process_manager;
+    $this->discovery = new AnnotatedClassDiscovery('Core', 'Condition');
+    $this->discovery = new AlterDecorator($this->discovery, 'condition_info');
+    $this->discovery = new CacheDecorator($this->discovery, 'condition:' . language(LANGUAGE_TYPE_INTERFACE)->langcode);
+
+    $this->factory = new DefaultFactory($this);
+  }
+
+  /**
+   * Override of \Drupal\Component\Plugin\PluginManagerBase::createInstance().
+   */
+  public function createInstance($plugin_id, array $configuration = array()) {
+    $plugin = $this->factory->createInstance($plugin_id, $configuration);
+    $plugin->setProcessorManager($this->processorManager);
+    $plugin->setExecutableManager($this);
+    return $plugin;
+  }
+
+  /**
+   * Implements \Drupal\Core\Executable\ExecutableManagerInterface::execute()
+   */
+  public function execute(ExecutableInterface $condition) {
+    $result = $condition->evaluate();
+    return $condition->isNegated() ? !$result : $result;
+  }
+
+}
diff --git a/core/modules/node/lib/Drupal/node/Plugin/Core/Condition/NodeType.php b/core/modules/node/lib/Drupal/node/Plugin/Core/Condition/NodeType.php
new file mode 100644
index 0000000..555f5c1
--- /dev/null
+++ b/core/modules/node/lib/Drupal/node/Plugin/Core/Condition/NodeType.php
@@ -0,0 +1,88 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\node\Plugin\Core\Condition\NodeType.
+ */
+
+namespace Drupal\node\Plugin\Core\Condition;
+
+use Drupal\condition\Plugin\ConditionPluginBase;
+use Drupal\Core\Annotation\Plugin;
+use Drupal\Core\Annotation\Translation;
+
+/**
+ * Provides a 'Node Type' condition.
+ *
+ * @Plugin(
+ *   id = "node_type",
+ *   label = @Translation("Node Bundle"),
+ *   module = "node",
+ *   context = {
+ *     "node" = {
+ *       "type" = "entity",
+ *       "constraints" = {
+ *         "EntityType" = "node"
+ *       }
+ *     },
+ *     "bundles" = {
+ *       "type" = "any"
+ *     }
+ *   }
+ * )
+ *
+ * @todo: Fix validation of multiple values and improve the bundles context
+ * definition to be more specific. See http://drupal.org/node/1913334.
+ */
+class NodeType extends ConditionPluginBase {
+
+  /**
+   * Implements \Drupal\condition\Plugin\ConditionInterface::form().
+   */
+  public function form($form, &$form_state) {
+    $form = parent::form($form, $form_state);
+    $values = $this->getContextValues();
+    $options = array();
+    foreach (node_type_get_types() as $type) {
+      $options[$type->type] = $type->name;
+    }
+    $form['bundles'] = array(
+      '#type' => 'checkboxes',
+      '#options' => $options,
+      '#required' => TRUE,
+      '#default_value' => $values['bundles'],
+    );
+    return $form;
+  }
+
+  /**
+   * Implements \Drupal\condition\ConditionInterface::extractFormValues().
+   */
+  public function extractFormValues($form, &$form_state) {
+    // @todo: How to set the value without triggering validation?
+    $this->setContextValue($form_state['values']['bundles']);
+    parent::extractFormValues($form, $form_state);
+  }
+
+  /**
+   * Implements \Drupal\condition\ConditionInterface::summary().
+   */
+  public function summary() {
+    $bundles = $this->getContextValue('bundles');
+    if (count($bundles) > 1) {
+      $last = array_pop($bundles);
+      $bundles = implode(', ', $bundles);
+      return t('The node bundle is @bundles or @last', array('@bundles' => $bundles, '@last' => $last));
+    }
+    return t('The node bundle is @bundle', array('@bundle' => reset($bundles)));
+  }
+
+  /**
+   * Implements \Drupal\condition\ConditionInterface::evaluate().
+   */
+  public function evaluate() {
+    $node = $this->getContextValue('node');
+    return in_array($node->type, $this->getContextValue('bundles'));
+  }
+
+}
diff --git a/core/modules/node/lib/Drupal/node/Tests/Condition/NodeConditionTest.php b/core/modules/node/lib/Drupal/node/Tests/Condition/NodeConditionTest.php
new file mode 100644
index 0000000..ca94276
--- /dev/null
+++ b/core/modules/node/lib/Drupal/node/Tests/Condition/NodeConditionTest.php
@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\condition\Tests\Condition\NodeConditionTest.
+ */
+
+namespace Drupal\node\Tests\Condition;
+
+use Drupal\simpletest\DrupalUnitTestBase;
+use Drupal\condition\Plugin\Type\ConditionManager;
+use Drupal\Core\Processor\ProcessorManager;
+
+/**
+ * Tests the node conditions.
+ */
+class NodeConditionTest extends DrupalUnitTestBase {
+
+  public static $modules = array('system', 'node', 'entity_test', 'field', 'condition');
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Node Condition Plugins',
+      'description' => 'Tests that conditions, provided by the node module, are working properly.',
+      'group' => 'Condition API',
+    );
+  }
+
+  protected function setUp() {
+    parent::setUp();
+    $this->installSchema('node', 'node_type');
+    $this->installSchema('node', 'node');
+    $this->installSchema('node', 'node_revision');
+    $this->installSchema('field', 'field_config');
+    $this->installSchema('field', 'field_config_instance');
+    $this->installSchema('entity_test', 'entity_test');
+  }
+
+  /**
+   * Tests conditions.
+   */
+  function testConditions() {
+    $processor = new ProcessorManager();
+    $manager = new ConditionManager($processor);
+
+    // Get some nodes of various types to check against.
+    $page = entity_create('node', array('type' => 'page', 'title' => $this->randomName()));
+    $page->save();
+    $article = entity_create('node', array('type' => 'article', 'title' => $this->randomName()));
+    $article->save();
+    $test = entity_create('node', array('type' => 'test', 'title' => $this->randomName()));
+    $test->save();
+
+    // Grab the node type condition and configure it to check against node type
+    // of 'article' and set the context to the page type node.
+    $condition = $manager->createInstance('node_type')
+      ->setContextValue('bundles', array('article'))
+      ->setContextValue('node', $page);
+    $this->assertFalse($condition->execute(), 'Page type nodes fail node type checks for articles.');
+    // Check for the proper summary.
+    $this->assertEqual('The node bundle is article', $condition->summary());
+
+    // Set the node type check to page.
+    $condition->setContextValue('bundles', array('page'));
+    $this->assertTrue($condition->execute(), 'Page type nodes pass node type checks for pages');
+    // Check for the proper summary.
+    $this->assertEqual('The node bundle is page', $condition->summary());
+
+    // Set the node type check to page or article.
+    $condition->setContextValue('bundles', array('page', 'article'));
+    $this->assertTrue($condition->execute(), 'Page type nodes pass node type checks for pages or articles');
+    // Check for the proper summary.
+    $this->assertEqual('The node bundle is page or article', $condition->summary());
+
+    // Set the context to the article node.
+    $condition->setContextValue('node', $article);
+    $this->assertTrue($condition->execute(), 'Article type nodes pass node type checks for pages or articles');
+
+    // Set the context to the test node.
+    $condition->setContextValue('node', $test);
+    $this->assertFalse($condition->execute(), 'Test type nodes pass node type checks for pages or articles');
+
+    // Check a greater than 2 bundles summary scenario.
+    $condition->setContextValue('bundles', array('page', 'article', 'test'));
+    $this->assertEqual('The node bundle is page, article or test', $condition->summary());
+
+    // Test validation.
+    $this->assertEqual($condition->validate()->count(), 0, 'Validation passes.');
+    $entity = entity_create('entity_test', array('name' => $this->randomString()));
+    $entity->save();
+    $condition->getContext('node')->setContextValue($entity);
+    $violations = $condition->validate();
+    $this->assertEqual($violations->count(), 1, 'Validation fails if another entity is passed as node.');
+    $this->assertEqual($violations[0]->getMessage(), t('The entity must be of type %type.', array('%type' => 'node')));
+  }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Plugin/ContextPluginTest.php b/core/modules/system/lib/Drupal/system/Tests/Plugin/ContextPluginTest.php
new file mode 100644
index 0000000..c22f222
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Plugin/ContextPluginTest.php
@@ -0,0 +1,194 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\system\Tests\Plugin\ContextPluginTest.
+ */
+
+namespace Drupal\system\Tests\Plugin;
+
+use Drupal\simpletest\DrupalUnitTestBase;
+use Drupal\plugin_test\Plugin\MockBlockManager;
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Component\Plugin\Exception\ContextException;
+
+/**
+ * Tests that context aware plugins function correctly.
+ */
+class ContextPluginTest extends DrupalUnitTestBase {
+
+  public static $modules = array('system', 'user', 'node');
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Contextual Plugins',
+      'description' => 'Tests that contexts are properly set and working within plugins.',
+      'group' => 'Plugin API',
+    );
+  }
+
+  protected function setUp() {
+    parent::setUp();
+    $this->installSchema('node', 'node_type');
+  }
+
+  /**
+   * Tests basic context definition and value getters and setters.
+   */
+  function testContext() {
+    $name = $this->randomName();
+    $manager = new MockBlockManager();
+    $plugin = $manager->createInstance('user_name');
+    // Create a node, add it as context, catch the exception.
+    $node = entity_create('node', array('title' => $name));
+
+    // Try to get a valid context that has not been set.
+    try {
+      $plugin->getContext('user');
+      $this->fail('The user context should not yet be set.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The user context is not yet set.');
+    }
+
+    // Try to get an invalid context.
+    try {
+      $plugin->getContext('node');
+      $this->fail('The node context should not be a valid context.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The node context is not a valid context.');
+    }
+
+    // Try to get a valid context value that has not been set.
+    try {
+      $plugin->getContextValue('user');
+      $this->fail('The user context should not yet be set.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The user context is not yet set.');
+    }
+
+    // Try to call a method of the plugin that requires context before it has
+    // been set.
+    try {
+      $plugin->getTitle();
+      $this->fail('The user context should not yet be set.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The user context is not yet set.');
+    }
+
+    // Try to get a context value that is not valid.
+    try {
+      $plugin->getContextValue('node');
+      $this->fail('The node context should not be a valid context.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The node context is not a valid context.');
+    }
+
+    // Try to pass the wrong class type as a context value.
+    try {
+      $plugin->setContextValue('user', $node);
+      $this->fail('The node context should fail validation for a user context.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The provided context value does not pass validation.');
+    }
+
+    // Set an appropriate context value appropriately and check to make sure
+    // its methods work as expected.
+    $user = entity_create('user', array('name' => $name));
+    $plugin->setContextValue('user', $user);
+    $this->assertEqual($user->label(), $plugin->getTitle());
+
+    // Test the getContextDefinitions() method.
+    $this->assertIdentical($plugin->getContextDefinitions(), array('user' => array('class' => 'Drupal\user\Plugin\Core\Entity\User')));
+
+    // Test the getContextDefinition() method for a valid context.
+    $this->assertEqual($plugin->getContextDefinition('user'), array('class' => 'Drupal\user\Plugin\Core\Entity\User'));
+
+    // Test the getContextDefinition() method for an invalid context.
+    try {
+      $plugin->getContextDefinition('node');
+      $this->fail('The node context should not be a valid context.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The node context is not a valid context.');
+    }
+
+    // Test typed data context plugins.
+    $typed_data_plugin = $manager->createInstance('string_context');
+
+    // Try to get a valid context value that has not been set.
+    try {
+      $typed_data_plugin->getContextValue('string');
+      $this->fail('The string context should not yet be set.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The string context is not yet set.');
+    }
+
+    // Try to call a method of the plugin that requires a context value before
+    // it has been set.
+    try {
+      $typed_data_plugin->getTitle();
+      $this->fail('The string context should not yet be set.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The string context is not yet set.');
+    }
+
+    // Set the context value appropriately and check the title.
+    $typed_data_plugin->setContextValue('string', $name);
+    $this->assertEqual($name, $typed_data_plugin->getTitle());
+
+    // Test Complex compound context handling.
+    $complex_plugin = $manager->createInstance('complex_context');
+
+    // With no contexts set, try to get the contexts.
+    try {
+      $complex_plugin->getContexts();
+      $this->fail('There should not be any contexts set yet.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'There are no set contexts.');
+    }
+
+    // With no contexts set, try to get the context values.
+    $values = $complex_plugin->getContextValues();
+    $this->assertIdentical(array_filter($values), array(), 'There are no set contexts.');
+
+    // Set the user context value.
+    $complex_plugin->setContextValue('user', $user);
+
+    // With only the user context set, try to get the contexts.
+    try {
+      $complex_plugin->getContexts();
+      $this->fail('The node context should not yet be set.');
+    }
+    catch (PluginException $e) {
+      $this->assertEqual($e->getMessage(), 'The node context is not yet set.');
+    }
+
+    // With only the user context set, try to get the context values.
+    $values = $complex_plugin->getContextValues();
+    $this->assertNull($values['node'], 'The node context is not yet set.');
+    $this->assertNotNull($values['user'], 'The user context is set');
+
+    $complex_plugin->setContextValue('node', $node);
+    $context_wrappers = $complex_plugin->getContexts();
+    // Make sure what came out of the wrappers is good.
+    $this->assertEqual($context_wrappers['user']->getContextValue()->label(), $user->label());
+    $this->assertEqual($context_wrappers['node']->getContextValue()->label(), $node->label());
+
+    // Make sure what comes out of the context values is good.
+    $contexts = $complex_plugin->getContextValues();
+    $this->assertEqual($contexts['user']->label(), $user->label());
+    $this->assertEqual($contexts['node']->label(), $node->label());
+
+    // Test the title method for the complex context plugin.
+    $this->assertEqual($user->label() . ' -- ' . $node->label(), $complex_plugin->getTitle());
+  }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php b/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php
index 5db9322..c927f7e 100644
--- a/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php
+++ b/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php
@@ -70,6 +70,28 @@ public function setUp() {
         'label' => 'Layout Foo',
         'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\MockLayoutBlock',
       ),
+      'user_name' => array(
+        'label' => 'User name',
+        'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\MockUserNameBlock',
+        'context' => array(
+          'user' => array('class' => 'Drupal\user\Plugin\Core\Entity\User')
+        ),
+      ),
+      'string_context' => array(
+        'label' => 'String typed data',
+        'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\TypedDataStringBlock',
+        'context' => array(
+          'string' => array('type' => 'string'),
+        ),
+      ),
+      'complex_context' => array(
+        'label' => 'Complex context',
+        'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\MockComplexContextBlock',
+        'context' => array(
+          'user' => array('class' => 'Drupal\user\Plugin\Core\Entity\User'),
+          'node' => array('class' => 'Drupal\node\Plugin\Core\Entity\Node'),
+        ),
+      ),
     );
     $this->defaultsTestPluginExpectedDefinitions = array(
       'test_block1' => array(
diff --git a/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php b/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php
index a401183..b3e8117 100644
--- a/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php
+++ b/core/modules/system/lib/Drupal/system/Tests/TypedData/TypedDataTest.php
@@ -197,6 +197,25 @@ public function testGetAndSet() {
     $this->assertEqual($typed_data->validate()->count(), 0);
     $typed_data->setValue('invalid');
     $this->assertEqual($typed_data->validate()->count(), 1, 'Validation detected invalid value.');
+
+    // Any type.
+    $value = array('foo');
+    $typed_data = $this->createTypedData(array('type' => 'any'), $value);
+    $this->assertIdentical($typed_data->getValue(), $value, 'Any value was fetched.');
+    $new_value = 'test@example.com';
+    $typed_data->setValue($new_value);
+    $this->assertIdentical($typed_data->getValue(), $new_value, 'Any value was changed.');
+    $this->assertTrue(is_string($typed_data->getString()), 'Any value was converted to string');
+    $this->assertEqual($typed_data->validate()->count(), 0);
+    $typed_data->setValue(NULL);
+    $this->assertNull($typed_data->getValue(), 'Any wrapper is null-able.');
+    $this->assertEqual($typed_data->validate()->count(), 0);
+    // We cannot test invalid values as everything is valid for the any type,
+    // but make sure an array or object value passes validation also.
+    $typed_data->setValue(array('entry'));
+    $this->assertEqual($typed_data->validate()->count(), 0);
+    $typed_data->setValue((object) array('entry'));
+    $this->assertEqual($typed_data->validate()->count(), 0);
   }
 
   /**
diff --git a/core/modules/system/system.module b/core/modules/system/system.module
index 223af2e..c51f234 100644
--- a/core/modules/system/system.module
+++ b/core/modules/system/system.module
@@ -2231,6 +2231,10 @@ function system_data_type_info() {
       'class' => '\Drupal\Core\TypedData\Type\Binary',
       'primitive type' => Primitive::BINARY,
     ),
+    'any' => array(
+      'label' => t('Any'),
+      'class' => '\Drupal\Core\TypedData\Type\Any',
+    ),
     'language' => array(
       'label' => t('Language'),
       'description' => t('A language object.'),
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockBlockManager.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockBlockManager.php
index fcf1824..7e29259 100644
--- a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockBlockManager.php
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockBlockManager.php
@@ -66,6 +66,35 @@ public function __construct() {
       'derivative' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\MockLayoutBlockDeriver',
     ));
 
+    // A block plugin that requires context to function. This block requires a
+    // user object in order to return the user name from the getTitle() method.
+    $this->discovery->setDefinition('user_name', array(
+      'label' => t('User name'),
+      'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\MockUserNameBlock',
+      'context' => array(
+        'user' => array('class' => 'Drupal\user\Plugin\Core\Entity\User')
+      ),
+    ));
+
+    // A block plugin that requires a typed data string context to function.
+    $this->discovery->setDefinition('string_context', array(
+      'label' => t('String typed data'),
+      'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\TypedDataStringBlock',
+      'context' => array(
+        'string' => array('type' => 'string'),
+      ),
+    ));
+
+    // A complex context plugin that requires both a user and node for context.
+    $this->discovery->setDefinition('complex_context', array(
+      'label' => t('Complex context'),
+      'class' => 'Drupal\plugin_test\Plugin\plugin_test\mock_block\MockComplexContextBlock',
+      'context' => array(
+        'user' => array('class' => 'Drupal\user\Plugin\Core\Entity\User'),
+        'node' => array('class' => 'Drupal\node\Plugin\Core\Entity\Node'),
+      ),
+    ));
+
     // In addition to finding all of the plugins available for a type, a plugin
     // type must also be able to create instances of that plugin. For example, a
     // specific instance of a "Main menu" menu block, configured to show just
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/MockComplexContextBlock.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/MockComplexContextBlock.php
new file mode 100644
index 0000000..1cb657a
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/MockComplexContextBlock.php
@@ -0,0 +1,24 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\plugin_test\Plugin\plugin_test\mock_block\MockComplexContextBlock.
+ */
+
+namespace Drupal\plugin_test\Plugin\plugin_test\mock_block;
+
+use Drupal\Core\Plugin\ContextAwarePluginBase;
+
+/**
+ * Implementation of a complex context plugin used by Plugin API context tests.
+ *
+ * @see \Drupal\plugin_test\Plugin\MockBlockManager
+ */
+class MockComplexContextBlock extends ContextAwarePluginBase {
+
+  public function getTitle() {
+    $user = $this->getContextValue('user');
+    $node = $this->getContextValue('node');
+    return $user->label() . ' -- ' . $node->label();
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/MockUserNameBlock.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/MockUserNameBlock.php
new file mode 100644
index 0000000..3fc1f84
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/MockUserNameBlock.php
@@ -0,0 +1,24 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\plugin_test\Plugin\plugin_test\mock_block\MockUserNameBlock.
+ */
+
+namespace Drupal\plugin_test\Plugin\plugin_test\mock_block;
+
+use Drupal\Core\Plugin\ContextAwarePluginBase;
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+
+/**
+ * Implementation of a user name block plugin used by Plugin API context test.
+ *
+ * @see \Drupal\plugin_test\Plugin\MockBlockManager
+ */
+class MockUserNameBlock extends ContextAwarePluginBase {
+
+  public function getTitle() {
+    $user = $this->getContextValue('user');
+    return $user->label();
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/TypedDataStringBlock.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/TypedDataStringBlock.php
new file mode 100644
index 0000000..14e0ab3
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/plugin_test/mock_block/TypedDataStringBlock.php
@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\plugin_test\Plugin\plugin_test\mock_block\TypedDataStringBlock.
+ */
+
+namespace Drupal\plugin_test\Plugin\plugin_test\mock_block;
+
+use Drupal\Core\Plugin\ContextAwarePluginBase;
+
+/**
+ * Implementation of a String TypedData contextual block plugin used by Plugin
+ * API context test.
+ *
+ * @see \Drupal\plugin_test\Plugin\MockBlockManager
+ */
+class TypedDataStringBlock extends ContextAwarePluginBase {
+
+  public function getTitle() {
+    return $this->getContextValue('string');
+  }
+}