Fix template angle bracket syntax in platform

Source/platform/graphics/ImageDecodingStore.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 87 matching lines @@
 
     OwnPtr<DecoderCacheEntry> newCacheEntry = DecoderCacheEntry::create(generator, decoder);
 
     MutexLocker lock(m_mutex);
     ASSERT(!m_decoderCacheMap.contains(newCacheEntry->cacheKey()));
     insertCacheInternal(newCacheEntry.release(), &m_decoderCacheMap, &m_decoderCacheKeyMap);
 }
 
 void ImageDecodingStore::removeDecoder(const ImageFrameGenerator* generator, const ImageDecoder* decoder)
 {
-    Vector<OwnPtr<CacheEntry> > cacheEntriesToDelete;
+    Vector<OwnPtr<CacheEntry>> cacheEntriesToDelete;
     {
         MutexLocker lock(m_mutex);
         DecoderCacheMap::iterator iter = m_decoderCacheMap.find(DecoderCacheEntry::makeCacheKey(generator, decoder));
         ASSERT_WITH_SECURITY_IMPLICATION(iter != m_decoderCacheMap.end());
 
         CacheEntry* cacheEntry = iter->value.get();
         ASSERT(cacheEntry->useCount());
         cacheEntry->decrementUseCount();
 
         // Delete only one decoder cache entry. Ownership of the cache entry
         // is transfered to cacheEntriesToDelete such that object can be deleted
         // outside of the lock.
         removeFromCacheInternal(cacheEntry, &cacheEntriesToDelete);
 
         // Remove from LRU list.
         removeFromCacheListInternal(cacheEntriesToDelete);
     }
 }
 
 void ImageDecodingStore::removeCacheIndexedByGenerator(const ImageFrameGenerator* generator)
 {
-    Vector<OwnPtr<CacheEntry> > cacheEntriesToDelete;
+    Vector<OwnPtr<CacheEntry>> cacheEntriesToDelete;
     {
         MutexLocker lock(m_mutex);
 
         // Remove image cache objects and decoder cache objects associated
         // with a ImageFrameGenerator.
         removeCacheIndexedByGeneratorInternal(&m_decoderCacheMap, &m_decoderCacheKeyMap, generator, &cacheEntriesToDelete);
 
         // Remove from LRU list as well.
         removeFromCacheListInternal(cacheEntriesToDelete);
     }
@@ skipping 40 matching lines @@
 int ImageDecodingStore::decoderCacheEntries()
 {
     MutexLocker lock(m_mutex);
     return m_decoderCacheMap.size();
 }
 
 void ImageDecodingStore::prune()
 {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"), "ImageDecodingStore::prune");
 
-    Vector<OwnPtr<CacheEntry> > cacheEntriesToDelete;
+    Vector<OwnPtr<CacheEntry>> cacheEntriesToDelete;
     {
         MutexLocker lock(m_mutex);
 
         // Head of the list is the least recently used entry.
         const CacheEntry* cacheEntry = m_orderedCacheList.head();
 
         // Walk the list of cache entries starting from the least recently used
         // and then keep them for deletion later.
         while (cacheEntry) {
             const bool isPruneNeeded = m_heapMemoryUsageInBytes > m_heapLimitInBytes || !m_heapLimitInBytes;
@@ skipping 24 matching lines @@
     typename U::KeyType key = cacheEntry->cacheKey();
     typename V::AddResult result = identifierMap->add(cacheEntry->generator(), typename V::MappedType());
     result.storedValue->value.add(key);
     cacheMap->add(key, cacheEntry);
 
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"), "ImageDecodingStoreHeapMemoryUsageBytes", m_heapMemoryUsageInBytes);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"), "ImageDecodingStoreNumOfDecoders", m_decoderCacheMap.size());
 }
 
 template<class T, class U, class V>
-void ImageDecodingStore::removeFromCacheInternal(const T* cacheEntry, U* cacheMap, V* identifierMap, Vector<OwnPtr<CacheEntry> >* deletionList)
+void ImageDecodingStore::removeFromCacheInternal(const T* cacheEntry, U* cacheMap, V* identifierMap, Vector<OwnPtr<CacheEntry>>* deletionList)
 {
     const size_t cacheEntryBytes = cacheEntry->memoryUsageInBytes();
     ASSERT(m_heapMemoryUsageInBytes >= cacheEntryBytes);
     m_heapMemoryUsageInBytes -= cacheEntryBytes;
 
     // Remove entry from identifier map.
     typename V::iterator iter = identifierMap->find(cacheEntry->generator());
     ASSERT(iter != identifierMap->end());
     iter->value.remove(cacheEntry->cacheKey());
     if (!iter->value.size())
         identifierMap->remove(iter);
 
     // Remove entry from cache map.
     deletionList->append(cacheMap->take(cacheEntry->cacheKey()));
 
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"), "ImageDecodingStoreHeapMemoryUsageBytes", m_heapMemoryUsageInBytes);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"), "ImageDecodingStoreNumOfDecoders", m_decoderCacheMap.size());
 }
 
-void ImageDecodingStore::removeFromCacheInternal(const CacheEntry* cacheEntry, Vector<OwnPtr<CacheEntry> >* deletionList)
+void ImageDecodingStore::removeFromCacheInternal(const CacheEntry* cacheEntry, Vector<OwnPtr<CacheEntry>>* deletionList)
 {
     if (cacheEntry->type() == CacheEntry::TypeDecoder) {
         removeFromCacheInternal(static_cast<const DecoderCacheEntry*>(cacheEntry), &m_decoderCacheMap, &m_decoderCacheKeyMap, deletionList);
     } else {
         ASSERT(false);
     }
 }
 
 template<class U, class V>
-void ImageDecodingStore::removeCacheIndexedByGeneratorInternal(U* cacheMap, V* identifierMap, const ImageFrameGenerator* generator, Vector<OwnPtr<CacheEntry> >* deletionList)
+void ImageDecodingStore::removeCacheIndexedByGeneratorInternal(U* cacheMap, V* identifierMap, const ImageFrameGenerator* generator, Vector<OwnPtr<CacheEntry>>* deletionList)
 {
     typename V::iterator iter = identifierMap->find(generator);
     if (iter == identifierMap->end())
         return;
 
     // Get all cache identifiers associated with generator.
     Vector<typename U::KeyType> cacheIdentifierList;
     copyToVector(iter->value, cacheIdentifierList);
 
     // For each cache identifier find the corresponding CacheEntry and remove it.
     for (size_t i = 0; i < cacheIdentifierList.size(); ++i) {
         ASSERT(cacheMap->contains(cacheIdentifierList[i]));
         const typename U::MappedType::PtrType cacheEntry = cacheMap->get(cacheIdentifierList[i]);
         ASSERT(!cacheEntry->useCount());
         removeFromCacheInternal(cacheEntry, cacheMap, identifierMap, deletionList);
     }
 }
 
-void ImageDecodingStore::removeFromCacheListInternal(const Vector<OwnPtr<CacheEntry> >& deletionList)
+void ImageDecodingStore::removeFromCacheListInternal(const Vector<OwnPtr<CacheEntry>>& deletionList)
 {
     for (size_t i = 0; i < deletionList.size(); ++i)
         m_orderedCacheList.remove(deletionList[i].get());
 }
 
 } // namespace blink