Rewrap comments to 80 columns in Source/platform/graphics/.

third_party/WebKit/Source/platform/graphics/ImageDecodingStore.h

 /*
  * 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 34 matching lines @@
 // FUNCTION
 //
 // ImageDecodingStore is a class used to manage cached decoder objects.
 //
 // EXTERNAL OBJECTS
 //
 // ImageDecoder
 //   A decoder object. It is used to decode raw data into bitmap images.
 //
 // ImageFrameGenerator
-//   This is a direct user of this cache. Responsible for generating bitmap images
-//   using an ImageDecoder. It contains encoded image data and is used to represent
-//   one image file. It is used to index image and decoder objects in the cache.
+//   This is a direct user of this cache. Responsible for generating bitmap
+//   images using an ImageDecoder. It contains encoded image data and is used to
+//   represent one image file. It is used to index image and decoder objects in
+//   the cache.
 //
 // THREAD SAFETY
 //
 // All public methods can be used on any thread.
 
 class PLATFORM_EXPORT ImageDecodingStore final {
   USING_FAST_MALLOC(ImageDecodingStore);
   WTF_MAKE_NONCOPYABLE(ImageDecodingStore);
 
  public:
   static std::unique_ptr<ImageDecodingStore> create() {
     return wrapUnique(new ImageDecodingStore);
   }
   ~ImageDecodingStore();
 
   static ImageDecodingStore& instance();
 
-  // Access a cached decoder object. A decoder is indexed by origin (ImageFrameGenerator)
-  // and scaled size. Return true if the cached object is found.
+  // Accesses a cached decoder object. A decoder is indexed by origin
+  // (ImageFrameGenerator) and scaled size. Returns true if the cached object is
+  // found.
   bool lockDecoder(const ImageFrameGenerator*,
                    const SkISize& scaledSize,
                    ImageDecoder**);
   void unlockDecoder(const ImageFrameGenerator*, const ImageDecoder*);
   void insertDecoder(const ImageFrameGenerator*, std::unique_ptr<ImageDecoder>);
   void removeDecoder(const ImageFrameGenerator*, const ImageDecoder*);
 
   // Remove all cache entries indexed by ImageFrameGenerator.
   void removeCacheIndexedByGenerator(const ImageFrameGenerator*);
 
@@ skipping 26 matching lines @@
     virtual ~CacheEntry() { ASSERT(!m_useCount); }
 
     const ImageFrameGenerator* generator() const { return m_generator; }
     int useCount() const { return m_useCount; }
     void incrementUseCount() { ++m_useCount; }
     void decrementUseCount() {
       --m_useCount;
       ASSERT(m_useCount >= 0);
     }
 
-    // FIXME: getSafeSize() returns size in bytes truncated to a 32-bits integer.
-    //        Find a way to get the size in 64-bits.
+    // FIXME: getSafeSize() returns the size in bytes truncated to a 32-bit
+    // integer. Find a way to get the size in 64-bits.
     virtual size_t memoryUsageInBytes() const = 0;
     virtual CacheType type() const = 0;
 
    protected:
     const ImageFrameGenerator* m_generator;
     int m_useCount;
 
    private:
     CacheEntry* m_prev;
     CacheEntry* m_next;
@@ skipping 59 matching lines @@
       U* cacheMap,
       V* identifierMap,
       Vector<std::unique_ptr<CacheEntry>>* deletionList);
 
   // Helper method to remove a cache entry. Uses the templated version base on
   // the type of cache entry.
   void removeFromCacheInternal(
       const CacheEntry*,
       Vector<std::unique_ptr<CacheEntry>>* deletionList);
 
-  // Helper method to remove all cache entries associated with a ImageFraneGenerator.
-  // Ownership of cache entries is transferred to deletionList.
+  // Helper method to remove all cache entries associated with an
+  // ImageFrameGenerator. Ownership of the cache entries is transferred to
+  // |deletionList|.
   template <class U, class V>
   void removeCacheIndexedByGeneratorInternal(
       U* cacheMap,
       V* identifierMap,
       const ImageFrameGenerator*,
       Vector<std::unique_ptr<CacheEntry>>* deletionList);
 
   // Helper method to remove cache entry pointers from the LRU list.
   void removeFromCacheListInternal(
       const Vector<std::unique_ptr<CacheEntry>>& deletionList);
 
   // A doubly linked list that maintains usage history of cache entries.
   // This is used for eviction of old entries.
   // Head of this list is the least recently used cache entry.
   // Tail of this list is the most recently used cache entry.
   DoublyLinkedList<CacheEntry> m_orderedCacheList;
 
-  // A lookup table for all decoder cache objects. Owns all decoder cache objects.
+  // A lookup table for all decoder cache objects. Owns all decoder cache
+  // objects.
   typedef HashMap<DecoderCacheKey, std::unique_ptr<DecoderCacheEntry>>
       DecoderCacheMap;
   DecoderCacheMap m_decoderCacheMap;
 
   // A lookup table to map ImageFrameGenerator to all associated
   // decoder cache keys.
   typedef HashSet<DecoderCacheKey> DecoderCacheKeySet;
   typedef HashMap<const ImageFrameGenerator*, DecoderCacheKeySet>
       DecoderCacheKeyMap;
   DecoderCacheKeyMap m_decoderCacheKeyMap;
 
   size_t m_heapLimitInBytes;
   size_t m_heapMemoryUsageInBytes;
 
   // Protect concurrent access to these members:
   //   m_orderedCacheList
   //   m_decoderCacheMap and all CacheEntrys stored in it
   //   m_decoderCacheKeyMap
   //   m_heapLimitInBytes
   //   m_heapMemoryUsageInBytes
   // This mutex also protects calls to underlying skBitmap's
   // lockPixels()/unlockPixels() as they are not threadsafe.
   Mutex m_mutex;
 };
 
 }  // namespace blink
 
 #endif