diff --git a/core/core.services.yml b/core/core.services.yml
index a83af34..610b486 100644
--- a/core/core.services.yml
+++ b/core/core.services.yml
@@ -158,7 +158,7 @@ services:
     tags:
       - { name: service_collector, call: addInvalidator, tag: cache_tags_invalidator }
   cache_tags.invalidator.checksum:
-    class: Drupal\Core\Cache\DatabaseCacheTagsChecksum
+    class: Drupal\Core\Cache\CacheCacheTagsChecksum
     arguments: ['@database']
     tags:
       - { name: cache_tags_invalidator}
diff --git a/core/lib/Drupal/Core/Cache/CacheCacheTagsChecksum.php b/core/lib/Drupal/Core/Cache/CacheCacheTagsChecksum.php
new file mode 100644
index 0000000..1c1bc15
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/CacheCacheTagsChecksum.php
@@ -0,0 +1,163 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Cache\CacheCacheTagsChecksum.
+ */
+
+namespace Drupal\Core\Cache;
+
+/**
+ * Cache tags invalidations checksum implementation that uses the database.
+ */
+class CacheCacheTagsChecksum implements CacheTagsChecksumInterface, CacheTagsInvalidatorInterface {
+
+  /**
+   * Backend storage
+   *
+   * @var CacheBackendInterface
+   */
+  protected $backend = NULL;
+
+
+  /**
+   * Contains already loaded cache invalidations from the database.
+   *
+   * @var array
+   */
+  protected $tagCache = array();
+
+  /**
+   * A list of tags that have already been invalidated in this request.
+   *
+   * Used to prevent the invalidation of the same cache tag multiple times.
+   *
+   * @var array
+   */
+  protected $invalidatedTags = array();
+
+  /**
+   * Constructs a ChainedFastCacheTagsChecksum object.
+   */
+  public function __construct($connection) {
+    // TODO:: THIS IS A QUICK WORKAROUND TO TEST THE SOLUTION.
+    $bin = 'tags';
+    $this->backend = new ChainedFastBackend(
+         new DatabaseBackend($connection, new DummyTagChecksum(), $bin),
+         new ApcuBackend($bin, 'siteprefix', new DummyTagChecksum()),
+        $bin
+      );
+  }
+
+  /**
+   * Increments a cache key.
+   * 
+   * TODO:// Cache backends SHOULD have this functionality!!!
+   * Many backends: wincache, couchbase, apcu, etc..
+   * already support this natively. The problem is that
+   * these backends expect the raw value to be stored as the cache
+   * data while Drupal is storing this data inside a cache
+   * object.
+   *
+   * @param string $cid
+   * @param int $increment
+   * @param int $default
+   */
+  protected function counter($cid, $increment, $default = 1) {
+    $data = NULL;
+    if ($cache = $this->backend->get($cid)) {
+      $data = $cache->data + $increment;
+    }
+    else {
+      $data = $default;
+    }
+    $this->backend->set($cid, $data);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateTags(array $tags) {
+    foreach ($tags as $tag) {
+      // Only invalidate tags once per request unless they are written again.
+      if (isset($this->invalidatedTags[$tag])) {
+        unset($tags[$tag]);
+        continue;
+      }
+      $this->invalidatedTags[$tag] = TRUE;
+      unset($this->tagCache[$tag]);
+      $this->counter($tag, 1);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCurrentChecksum(array $tags) {
+    // Remove tags that were already invalidated during this request from the
+    // static caches so that another invalidation can occur later in the same
+    // request. Without that, written cache items would not be invalidated
+    // correctly.
+    foreach ($tags as $tag) {
+      unset($this->invalidatedTags[$tag]);
+    }
+    return $this->calculateChecksum($tags);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isValid($checksum, array $tags) {
+    return $checksum == $this->calculateChecksum($tags);
+  }
+
+  /**
+   * Calculates the current checksum for a given set of tags.
+   *
+   * @param array $tags
+   *   The array of tags to calculate the checksum for.
+   *
+   * @return int
+   *   The calculated checksum.
+   */
+  protected function calculateChecksum(array $tags) {
+    $checksum = 0;
+
+    $query_tags = array_diff($tags, array_keys($this->tagCache));
+    if ($query_tags) {
+      $db_tags = array();
+
+      foreach($this->backend->getMultiple($query_tags) as $cid => $cache) {
+        $db_tags[$cid] = $cache->data;
+      }
+
+      // If we were not retrieve a tag (because it has never been invalidated) make
+      // sure that we initialize it, othewise the storage backend will keep looking
+      // for it once again and again in the persistent backend, and that is something
+      // we want to avoid!
+      $missing_tags = array_diff($query_tags, $db_tags);
+      foreach ($missing_tags as $tag) {
+        $this->counter($tag, 1);
+      }
+
+      $this->tagCache += $db_tags;
+
+      // Fill static cache with empty objects for tags not found in the database.
+      $this->tagCache += array_fill_keys(array_diff($query_tags, array_keys($db_tags)), 0);
+    }
+
+    foreach ($tags as $tag) {
+      $checksum += $this->tagCache[$tag];
+    }
+
+    return $checksum;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function reset() {
+    $this->tagCache = array();
+    $this->invalidatedTags = array();
+  }
+}
diff --git a/core/lib/Drupal/Core/Cache/CacheRawBackendInterface.php b/core/lib/Drupal/Core/Cache/CacheRawBackendInterface.php
new file mode 100644
index 0000000..d0e891d
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/CacheRawBackendInterface.php
@@ -0,0 +1,219 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Cache\CacheRawBackendInterface.
+ */
+
+namespace Drupal\Core\Cache;
+
+/**
+ * Defines an interface for raw cache implementations.
+ *
+ * The cache indentifiers are case sensitive.
+ *
+ * @ingroup cache
+ */
+interface CacheRawBackendInterface {
+
+  /**
+   * Indicates that the item should never be removed unless explicitly deleted.
+   */
+  const CACHE_PERMANENT = -1;
+
+  /**
+   * Returns data from the persistent cache.
+   *
+   * @param string $cid
+   *   The cache ID of the data to retrieve.
+   *
+   * @return object|false
+   *   The cache item or FALSE on failure.
+   *
+   * @see \Drupal\Core\Cache\CacheBackendInterface::getMultiple()
+   */
+  public function get($cid);
+
+  /**
+   * Returns data from the persistent cache when given an array of cache IDs.
+   *
+   * @param array $cids
+   *   An array of cache IDs for the data to retrieve. This is passed by
+   *   reference, and will have the IDs successfully returned from cache
+   *   removed.
+   * @param bool $allow_invalid
+   *   (optional) If TRUE, cache items may be returned even if they have expired
+   *   or been invalidated. Such items may sometimes be preferred, if the
+   *   alternative is recalculating the value stored in the cache, especially
+   *   if another concurrent thread is already recalculating the same value. The
+   *   "valid" property of the returned objects indicates whether the items are
+   *   valid or not. Defaults to FALSE.
+   *
+   * @return array
+   *   An array of cache item objects indexed by cache ID.
+   *
+   * @see \Drupal\Core\Cache\CacheBackendInterface::get()
+   */
+  public function getMultiple(&$cids);
+
+  /**
+   * Stores data in the persistent cache.
+   *
+   * Core cache implementations set the created time on cache item with
+   * microtime(TRUE) rather than REQUEST_TIME_FLOAT, because the created time
+   * of cache items should match when they are created, not when the request
+   * started. Apart from being more accurate, this increases the chance an
+   * item will legitimately be considered valid.
+   *
+   * @param string $cid
+   *   The cache ID of the data to store.
+   * @param mixed $data
+   *   The data to store in the cache.
+   *   Some storage engines only allow objects up to a maximum of 1MB in size to
+   *   be stored by default. When caching large arrays or similar, take care to
+   *   ensure $data does not exceed this size.
+   * @param int $expire
+   *   One of the following values:
+   *   - CacheBackendInterface::CACHE_PERMANENT: Indicates that the item should
+   *     not be removed unless it is deleted explicitly.
+   *   - A Unix timestamp: Indicates that the item will be considered invalid
+   *     after this time, i.e. it will not be returned by get() unless
+   *     $allow_invalid has been set to TRUE. When the item has expired, it may
+   *     be permanently deleted by the garbage collector at any time.
+   *
+   * @see \Drupal\Core\Cache\CacheBackendInterface::get()
+   * @see \Drupal\Core\Cache\CacheBackendInterface::getMultiple()
+   */
+  public function set($cid, $data, $expire = Cache::PERMANENT);
+
+  /**
+   * Store multiple items in the persistent cache.
+   *
+   * @param array $items
+   *   An array of cache items, keyed by cid. In the form:
+   *   @code
+   *   $items = array(
+   *     $cid => array(
+   *       // Required, will be automatically serialized if not a string.
+   *       'data' => $data,
+   *       // Optional, defaults to CacheRawBackendInterface::CACHE_PERMANENT.
+   *       'expire' => CacheBackendInterface::CACHE_PERMANENT,
+   *     ),
+   *   );
+   *   @endcode
+   */
+  public function setMultiple(array $items);
+
+  /**
+   * Deletes an item from the cache.
+   *
+   * This allows callers to retrieve the
+   * invalid item by calling get() with $allow_invalid set to TRUE. In some cases
+   * an invalid item may be acceptable rather than having to rebuild the cache.
+   *
+   * @param string $cid
+   *   The cache ID to delete.
+   *
+   * @see \Drupal\Core\Cache\CacheBackendInterface::invalidate()
+   * @see \Drupal\Core\Cache\CacheBackendInterface::deleteMultiple()
+   * @see \Drupal\Core\Cache\CacheBackendInterface::deleteAll()
+   */
+  public function delete($cid);
+
+  /**
+   * Deletes multiple items from the cache.
+   *
+   * This allows callers to
+   * retrieve the invalid items by calling get() with $allow_invalid set to TRUE.
+   * In some cases an invalid item may be acceptable rather than having to
+   * rebuild the cache.
+   *
+   * @param array $cids
+   *   An array of cache IDs to delete.
+   *
+   * @see \Drupal\Core\Cache\CacheBackendInterface::delete()
+   * @see \Drupal\Core\Cache\CacheBackendInterface::deleteAll()
+   */
+  public function deleteMultiple(array $cids);
+
+  /**
+   * Deletes all cache items in a bin.
+   *
+   * @see \Drupal\Core\Cache\CacheBackendInterface::delete()
+   * @see \Drupal\Core\Cache\CacheBackendInterface::deleteMultiple()
+   */
+  public function deleteAll();
+
+  /**
+   * Increments or decrements a cache item.
+   *
+   * Cache items that store numeric values can be incremented and
+   * decremented.
+   *
+   * @param string $cid
+   *   The item to increment and/or decrement.
+   * @param int $increment
+   *   The amount to add to the cache value. Can be a negative number.
+   * @param int $initial
+   *   If the item does not exist already, the initial value.
+   *
+   * @return void
+   */
+  public function counter($cid, $increment, $initial = 0);
+
+  /**
+   * Increments or decrements a cache item.
+   * 
+   * @param string[] $cids
+   *   The item to increment and/or decrement.
+   * @param int $increment
+   *   The amount to add to the cache value. Can be a negative number.
+   * @param int $initial
+   *   If the item does not exist already, the initial value.
+   */
+  public function counterMultiple(array $cids, $increment, $initial = 0);
+
+  /**
+   * Reset the expiration of a key to a new value.
+   *
+   * Allows you to reset the expiration of a key.
+   * Previous ways of doing the same thing included sending the key's value to the server again,
+   * touch() obviates that.
+   *
+   * @param string $cid
+   *   An array of cache IDs to increment/decrement.
+   * @param int $expire
+   *   The amount to add to the cache value. Can be a negative number.
+   *
+   * @return void
+   */
+  public function touch($cid, $expire = Cache::PERMANENT);
+
+  /**
+   * Reset the expiration of a key to a new value.
+   *
+   * Allows you to reset the expiration of a key.
+   * Previous ways of doing the same thing included sending the key's value to the server again,
+   * touch() obviates that.
+   *
+   * @param string[] $cids
+   *   An array of cache IDs to increment/decrement.
+   * @param int $expire
+   *   The amount to add to the cache value. Can be a negative number.
+   *
+   * @return void
+   */
+  public function touchMultiple(array $cids, $expire = Cache::PERMANENT);
+
+  /**
+   * Performs garbage collection on a cache bin.
+   *
+   * The backend may choose to delete expired or invalidated items.
+   */
+  public function garbageCollection();
+
+  /**
+   * Remove a cache bin.
+   */
+  public function removeBin();
+}
diff --git a/core/lib/Drupal/Core/Cache/ChainedFastBackend.php b/core/lib/Drupal/Core/Cache/ChainedFastBackend.php
index 051f38d..7a820a6 100644
--- a/core/lib/Drupal/Core/Cache/ChainedFastBackend.php
+++ b/core/lib/Drupal/Core/Cache/ChainedFastBackend.php
@@ -58,6 +58,13 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI
   const LAST_WRITE_TIMESTAMP_PREFIX = 'last_write_timestamp_';
 
   /**
+   * Identifier for the current webhead/process
+   *
+   * @var string
+   */
+  protected $headId;
+
+  /**
    * @var string
    */
   protected $bin;
@@ -77,6 +84,13 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI
   protected $fastBackend;
 
   /**
+   * Last time this binary has been marked as outdated.
+   *
+   * @var int
+   */
+  protected $last_invalidation = NULL;
+
+  /**
    * The time at which the last write to this cache bin happened.
    *
    * @var float
@@ -84,6 +98,31 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI
   protected $lastWriteTimestamp;
 
   /**
+   * Wether or not invalidations should
+   * be persisted at shutdown.
+   *
+   * @var bool
+   */
+  protected $persistOnShutdown;
+
+  /**
+   * Generate or retrieve a key that identifies
+   * the instance of the fastBackend.
+   *
+   * @return string
+   */
+  protected function GetHeadId() {
+    if ($cache = $this->fastBackend->get('headid')) {
+      return $cache->data;
+    }
+
+    // Generate a unique ID for this fast backend.
+    $id = uniqid(microtime(TRUE), TRUE);
+    $this->fastBackend->set('headid', $id);
+    return $id;
+  }
+
+  /**
    * Constructs a ChainedFastBackend object.
    *
    * @param \Drupal\Core\Cache\CacheBackendInterface $consistent_backend
@@ -96,7 +135,9 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI
   public function __construct(CacheBackendInterface $consistent_backend, CacheBackendInterface $fast_backend, $bin) {
     $this->consistentBackend = $consistent_backend;
     $this->fastBackend = $fast_backend;
+    $this->headId = $this->GetHeadId();
     $this->bin = 'cache_' . $bin;
+    $this->persistOnShutdown = TRUE; //\Drupal\Core\Site\Settings::get('cache_persist_defer', FALSE);
     $this->lastWriteTimestamp = NULL;
   }
 
@@ -167,11 +208,16 @@ public function getMultiple(&$cids, $allow_invalid = FALSE) {
     // backend, retrieve them from the consistent backend and store them in the
     // fast one.
     if ($cids) {
+      $missing = array();
       foreach ($this->consistentBackend->getMultiple($cids, $allow_invalid) as $item) {
         $cache[$item->cid] = $item;
-        // Don't write the cache tags to the fast backend as any cache tag
-        // invalidation results in an invalidation of the whole fast backend.
-        $this->fastBackend->set($item->cid, $item->data, $item->expire);
+        $missing[$item->cid] = (array) $item;
+      }
+      $this->fastBackend->setMultiple($missing);
+      // This means that the persistent backend has no lastWriteTimestamp
+      // but we were able to retrieve data from it....
+      if (!$last_write_timestamp && !empty($missing)) {
+        $this->markAsOutdated();
       }
     }
 
@@ -183,10 +229,8 @@ public function getMultiple(&$cids, $allow_invalid = FALSE) {
    */
   public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = array()) {
     $this->consistentBackend->set($cid, $data, $expire, $tags);
+    $this->fastBackend->set($cid, $data, $expire, $tags);
     $this->markAsOutdated();
-    // Don't write the cache tags to the fast backend as any cache tag
-    // invalidation results in an invalidation of the whole fast backend.
-    $this->fastBackend->set($cid, $data, $expire);
   }
 
   /**
@@ -194,13 +238,8 @@ public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = array
    */
   public function setMultiple(array $items) {
     $this->consistentBackend->setMultiple($items);
-    $this->markAsOutdated();
-    // Don't write the cache tags to the fast backend as any cache tag
-    // invalidation results in an invalidation of the whole fast backend.
-    foreach ($items as &$item) {
-      unset($item['tags']);
-    }
     $this->fastBackend->setMultiple($items);
+    $this->markAsOutdated();
   }
 
   /**
@@ -208,6 +247,7 @@ public function setMultiple(array $items) {
    */
   public function delete($cid) {
     $this->consistentBackend->deleteMultiple(array($cid));
+    $this->fastBackend->deleteMultiple(array($cid));
     $this->markAsOutdated();
   }
 
@@ -216,6 +256,7 @@ public function delete($cid) {
    */
   public function deleteMultiple(array $cids) {
     $this->consistentBackend->deleteMultiple($cids);
+    $this->fastBackend->deleteMultiple($cids);
     $this->markAsOutdated();
   }
 
@@ -224,6 +265,7 @@ public function deleteMultiple(array $cids) {
    */
   public function deleteAll() {
     $this->consistentBackend->deleteAll();
+    $this->fastBackend->deleteAll();
     $this->markAsOutdated();
   }
 
@@ -239,6 +281,7 @@ public function invalidate($cid) {
    */
   public function invalidateMultiple(array $cids) {
     $this->consistentBackend->invalidateMultiple($cids);
+    $this->fastBackend->invalidateMultiple($cids);
     $this->markAsOutdated();
   }
 
@@ -249,6 +292,9 @@ public function invalidateTags(array $tags) {
     if ($this->consistentBackend instanceof CacheTagsInvalidatorInterface) {
       $this->consistentBackend->invalidateTags($tags);
     }
+    if ($this->fastBackend instanceof CacheTagsInvalidatorInterface) {
+      $this->fastBackend->invalidateTags($tags);
+    }
     $this->markAsOutdated();
   }
 
@@ -257,6 +303,7 @@ public function invalidateTags(array $tags) {
    */
   public function invalidateAll() {
     $this->consistentBackend->invalidateAll();
+    $this->fastBackend->invalidateAll();
     $this->markAsOutdated();
   }
 
@@ -289,7 +336,17 @@ public function reset() {
   protected function getLastWriteTimestamp() {
     if ($this->lastWriteTimestamp === NULL) {
       $cache = $this->consistentBackend->get(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin);
-      $this->lastWriteTimestamp = $cache ? $cache->data : 0;
+      if ($cache && $cache->data['head'] != $this->headId) {
+        $this->lastWriteTimestamp = $cache->data['timestamp'];
+      }
+      else {
+        // If we are here this means that either the binary has never been invalidated,
+        // or that the last invalidation was actually made by ourselves so we retain
+        // the previous invalidation timestamp that we had.
+        $current = $cache && $cache->data['head'] == $this->headId ? $cache->data['timestamp'] : 0;
+        $cache = $this->fastBackend->get(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin);
+        $this->lastWriteTimestamp = $cache && !empty($cache->data) ? $cache->data : $current;
+      }
     }
     return $this->lastWriteTimestamp;
   }
@@ -307,8 +364,24 @@ protected function markAsOutdated() {
     // costs one additional roundtrip to the persistent cache.
     $now = round(microtime(TRUE) + .001, 3);
     if ($now > $this->getLastWriteTimestamp()) {
-      $this->lastWriteTimestamp = $now;
-      $this->consistentBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp);
+      if ($this->persistOnShutdown) {
+        // Invalidate when the object is destroyed.
+        $this->last_invalidation = $now;
+      }
+      else {
+        $this->fastBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp);
+        $this->consistentBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, array('head' => $this->headId, 'timestamp' => $now));
+      }
+    }
+  }
+
+  /**
+   * Shutdown functions.
+   */
+  function __destruct() {
+    if ($this->persistOnShutdown && !empty($this->last_invalidation)) {
+      $this->fastBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp);
+      $this->consistentBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, array('head' => $this->headId, 'timestamp' => $this->last_invalidation));
     }
   }
 
diff --git a/core/lib/Drupal/Core/Cache/ChainedFastBackendFactory.php b/core/lib/Drupal/Core/Cache/ChainedFastBackendFactory.php
index bba9d94..96c3aca 100644
--- a/core/lib/Drupal/Core/Cache/ChainedFastBackendFactory.php
+++ b/core/lib/Drupal/Core/Cache/ChainedFastBackendFactory.php
@@ -57,14 +57,8 @@ public function __construct(Settings $settings = NULL, $consistent_service_name
       $fast_service_name = 'cache.backend.apcu';
     }
 
+    $this->fastServiceName = $fast_service_name;
     $this->consistentServiceName = $consistent_service_name;
-
-    // Do not use the fast chained backend during installation. In those cases,
-    // we expect many cache invalidations and writes, the fast chained cache
-    // backend performs badly in such a scenario.
-    if (!drupal_installation_attempted()) {
-      $this->fastServiceName = $fast_service_name;
-    }
   }
 
   /**
diff --git a/core/lib/Drupal/Core/Cache/DummyTagChecksum.php b/core/lib/Drupal/Core/Cache/DummyTagChecksum.php
new file mode 100644
index 0000000..86da07b
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/DummyTagChecksum.php
@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Cache\DummyTagChecksum.
+ */
+
+namespace Drupal\Core\Cache;
+
+use Drupal\Core\Cache\CacheTagsChecksumInterface;
+use Drupal\Core\Cache\CacheTagsInvalidatorInterface;
+
+/**
+ * Stub checksum interface, for when you need to use a cache backend
+ * without tag invalidation support.
+ */
+class DummyTagChecksum implements CacheTagsChecksumInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCurrentChecksum(array $tags) {
+    if (!empty($tags)) {
+      throw new \Exception("bad business");
+    }
+    return 0;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isValid($checksum, array $tags) { 
+    if (!empty($tags) || !empty($checksum)) {
+      throw new \Exception("bad business");
+    }
+    return TRUE;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function reset() { return; }
+}
\ No newline at end of file
diff --git a/core/lib/Drupal/Core/DrupalKernel.php b/core/lib/Drupal/Core/DrupalKernel.php
index 278826e..b10a876 100644
--- a/core/lib/Drupal/Core/DrupalKernel.php
+++ b/core/lib/Drupal/Core/DrupalKernel.php
@@ -78,7 +78,7 @@ class DrupalKernel implements DrupalKernelInterface, TerminableInterface {
         'arguments' => ['@database', '@cache_tags_provider.container', 'container'],
       ],
       'cache_tags_provider.container' => [
-        'class' => 'Drupal\Core\Cache\DatabaseCacheTagsChecksum',
+        'class' => 'Drupal\Core\Cache\CacheCacheTagsChecksum',
         'arguments' => ['@database'],
       ],
     ],
diff --git a/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php b/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php
index 11e1600..26dd2b3 100644
--- a/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php
+++ b/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php
@@ -44,8 +44,10 @@ class ChainedFastBackendTest extends UnitTestCase {
   public function testGetDoesntHitConsistentBackend() {
     $consistent_cache = $this->getMock('Drupal\Core\Cache\CacheBackendInterface');
     $timestamp_cid = ChainedFastBackend::LAST_WRITE_TIMESTAMP_PREFIX . 'cache_foo';
-    // Use the request time because that is what we will be comparing against.
-    $timestamp_item = (object) array('cid' => $timestamp_cid, 'data' => (int) $_SERVER['REQUEST_TIME'] - 60);
+    $headid = uniqid(microtime(TRUE), TRUE);
+    // Using a future time to make sure that proper head detection is being enforced. If it is this head
+    // invalidating the binary, the value from the fastCache should be considered instead.
+    $timestamp_item = (object) array('cid' => $timestamp_cid, 'data' => array('timestamp' => (int) $_SERVER['REQUEST_TIME'] + 60, 'head' => $headid));
     $consistent_cache->expects($this->once())
       ->method('get')->with($timestamp_cid)
       ->will($this->returnValue($timestamp_item));
@@ -54,6 +56,8 @@ public function testGetDoesntHitConsistentBackend() {
 
     $fast_cache = new MemoryBackend('foo');
     $fast_cache->set('foo', 'baz');
+    $fast_cache->set($timestamp_cid, (int) $_SERVER['REQUEST_TIME'] - 60);
+    $fast_cache->set('headid', $headid);
 
     $chained_fast_backend = new ChainedFastBackend(
       $consistent_cache,
@@ -67,10 +71,19 @@ public function testGetDoesntHitConsistentBackend() {
    * Tests a fast cache miss gets data from the consistent cache backend.
    */
   public function testFallThroughToConsistentCache() {
+    $headid = uniqid(microtime(TRUE), TRUE);
     $timestamp_item = (object) array(
       'cid' => ChainedFastBackend::LAST_WRITE_TIMESTAMP_PREFIX . 'cache_foo',
-      'data' => time() + 60, // Time travel is easy.
+      'data' => array('timestamp' => time() + 60, 'head' => $headid)
     );
+    $timestamp_item_fast = (object) array(
+      'cid' => ChainedFastBackend::LAST_WRITE_TIMESTAMP_PREFIX . 'cache_foo',
+      'data' => time() + 60,
+    );
+    $head_item = (object) array(
+      'cid' => 'headid',
+      'data' => $headid
+      );
     $cache_item = (object) array(
       'cid' => 'foo',
       'data' => 'baz',
@@ -94,16 +107,24 @@ public function testFallThroughToConsistentCache() {
       ->with(array($cache_item->cid))
       ->will($this->returnValue(array($cache_item->cid => $cache_item)));
 
+    // Cache miss for headid
+    $fast_cache->expects($this->at(0))
+      ->method('get')
+      ->with('headid')
+      ->will($this->returnValue($head_item));
+
+    // Retrieve the timestamp.
+    $fast_cache->expects($this->at(1))
+    ->method('get')
+    ->with($timestamp_item_fast->cid)
+    ->will($this->returnValue($timestamp_item_fast));
+
     // We should get a call for the cache item on the fast backend.
     $fast_cache->expects($this->once())
       ->method('getMultiple')
       ->with(array($cache_item->cid))
       ->will($this->returnValue(array($cache_item->cid => $cache_item)));
 
-    // We should get a call to set the cache item on the fast backend.
-    $fast_cache->expects($this->once())
-      ->method('set')
-      ->with($cache_item->cid, $cache_item->data, $cache_item->expire);
 
     $chained_fast_backend = new ChainedFastBackend(
       $consistent_cache,
@@ -112,5 +133,4 @@ public function testFallThroughToConsistentCache() {
     );
     $this->assertEquals('baz', $chained_fast_backend->get('foo')->data);
   }
-
 }
diff --git a/web.config b/web.config
index 782d4ae..f168388 100644
--- a/web.config
+++ b/web.config
@@ -1,9 +1,7 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<configuration>
+<configuration>
   <system.webServer>
     <!-- Don't show directory listings for URLs which map to a directory. -->
     <directoryBrowse enabled="false" />
-
     <!--
        Caching configuration was not delegated by default. Some hosters may not
        delegate the caching configuration to site owners by default and that
@@ -18,14 +16,12 @@
       </profiles>
     </caching>
      -->
-
     <rewrite>
       <rules>
         <rule name="Protect files and directories from prying eyes" stopProcessing="true">
           <match url="\.(engine|inc|install|module|profile|po|sh|.*sql|theme|twig|tpl(\.php)?|xtmpl|yml|svn-base)$|^(code-style\.pl|Entries.*|Repository|Root|Tag|Template|all-wcprops|entries|format)$" />
           <action type="CustomResponse" statusCode="403" subStatusCode="0" statusReason="Forbidden" statusDescription="Access is forbidden." />
         </rule>
-
         <rule name="Force simple error message for requests for non-existent favicon.ico" stopProcessing="true">
           <match url="favicon\.ico" />
           <action type="CustomResponse" statusCode="404" subStatusCode="1" statusReason="File Not Found" statusDescription="The requested file favicon.ico was not found" />
@@ -33,11 +29,10 @@
             <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
           </conditions>
         </rule>
-
-    <!-- To redirect all users to access the site WITH the 'www.' prefix,
+        <!-- To redirect all users to access the site WITH the 'www.' prefix,
      http://example.com/foo will be redirected to http://www.example.com/foo)
      adapt and uncomment the following:   -->
-    <!--
+        <!--
         <rule name="Redirect to add www" stopProcessing="true">
           <match url="^(.*)$" ignoreCase="false" />
           <conditions>
@@ -46,11 +41,10 @@
           <action type="Redirect" redirectType="Permanent" url="http://www.example.com/{R:1}" />
         </rule>
     -->
-
-    <!-- To redirect all users to access the site WITHOUT the 'www.' prefix,
+        <!-- To redirect all users to access the site WITHOUT the 'www.' prefix,
      http://www.example.com/foo will be redirected to http://example.com/foo)
      adapt and uncomment the following:   -->
-    <!--
+        <!--
         <rule name="Redirect to remove www" stopProcessing="true">
           <match url="^(.*)$" ignoreCase="false" />
           <conditions>
@@ -59,7 +53,6 @@
           <action type="Redirect" redirectType="Permanent" url="http://example.com/{R:1}" />
         </rule>
     -->
-
         <!-- Pass all requests not referring directly to files in the filesystem
          to index.php. -->
         <rule name="Short URLS" stopProcessing="true">
@@ -73,20 +66,18 @@
         </rule>
       </rules>
     </rewrite>
-
-  <!-- If running Windows Server 2008 R2 this can be commented out -->
+    <!-- If running Windows Server 2008 R2 this can be commented out -->
     <!-- httpErrors>
       <remove statusCode="404" subStatusCode="-1" />
       <error statusCode="404" prefixLanguageFilePath="" path="/index.php" responseMode="ExecuteURL" />
     </httpErrors -->
-
     <defaultDocument>
-     <!-- Set the default document -->
+      <!-- Set the default document -->
       <files>
-         <clear />
+        <clear />
         <add value="index.php" />
       </files>
     </defaultDocument>
-
+    <handlers configSource="handlers.config" />
   </system.webServer>
-</configuration>
+</configuration>
\ No newline at end of file