Remove special handling for MEM_*_SER

This special handling sacrifices CPU cycles for memory usage by
introducing an additional step to deserialize the serialized bytes
put into BlockManager. This may cause a performance regression in
some cases.

For now, let's keep the functionality the same as before, and only
include style changes in this PR. This is a precursor to another
incoming PR that changes the way unroll RDD partitions.

Author: andrewor14

core/src/main/scala/org/apache/spark/CacheManager.scala

@@ -143,19 +143,10 @@ private[spark] class CacheManager(blockManager: BlockManager) extends Logging {
          * to the BlockManager as an iterator and expect to read it back later. This is because
          * we may end up dropping a partition from memory store before getting it back, e.g.
          * when the entirety of the RDD does not fit in memory. */
-        if (storageLevel.deserialized) {
-          val elements = new ArrayBuffer[Any]
-          elements ++= values
-          updatedBlocks ++= blockManager.put(key, elements, storageLevel, tellMaster = true)
-          elements.iterator
-        } else {
-          /* This RDD is to be cached in memory in the form of serialized bytes. In this case,
-           * we only unroll the serialized form of the data, because the deserialized form may
-           * be much larger and may not fit in memory. */
-          val bytes = blockManager.dataSerialize(key, values)
-          updatedBlocks ++= blockManager.putBytes(key, bytes, storageLevel, tellMaster = true)
-          blockManager.dataDeserialize(key, bytes)
-        }
+        val elements = new ArrayBuffer[Any]
+        elements ++= values
+        updatedBlocks ++= blockManager.put(key, elements, storageLevel, tellMaster = true)
+        elements.iterator
       }
     }
     cachedValues.asInstanceOf[Iterator[T]]