Move PresentationAttributeCacheCleaner timer to main thread's timer task runner.

third_party/WebKit/Source/core/dom/PresentationAttributeStyle.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/dom/PresentationAttributeStyle.h"
 
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/Element.h"
 #include "core/html/HTMLInputElement.h"
 #include "platform/Timer.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebScheduler.h"
+#include "public/platform/WebThread.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/HashMap.h"
 #include "wtf/text/CString.h"
 #include <algorithm>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 struct PresentationAttributeCacheKey {
@@ skipping 21 matching lines @@
 using PresentationAttributeCache =
     HeapHashMap<unsigned,
                 Member<PresentationAttributeCacheEntry>,
                 AlreadyHashed>;
 static PresentationAttributeCache& presentationAttributeCache() {
   DEFINE_STATIC_LOCAL(PresentationAttributeCache, cache,
                       (new PresentationAttributeCache));
   return cache;
 }
 
+// This is a singleton (held via DEFINE_STATIC_LOCAL).
+// Thus it is appropriate to use the main thread's timer task runner, rather
+// than one associated with a particular frame.
 class PresentationAttributeCacheCleaner {
   WTF_MAKE_NONCOPYABLE(PresentationAttributeCacheCleaner);
   USING_FAST_MALLOC(PresentationAttributeCacheCleaner);
 
  public:
   PresentationAttributeCacheCleaner()
       : m_hitCount(0),
-        m_cleanTimer(this, &PresentationAttributeCacheCleaner::cleanCache) {}
+        m_cleanTimer(
+            Platform::current()->mainThread()->scheduler()->timerTaskRunner(),
+            this,
+            &PresentationAttributeCacheCleaner::cleanCache) {}
 
   void didHitPresentationAttributeCache() {
     if (presentationAttributeCache().size() <
         minimumPresentationAttributeCacheSizeForCleaning)
       return;
 
     m_hitCount++;
 
     if (!m_cleanTimer.isActive())
       m_cleanTimer.startOneShot(presentationAttributeCacheCleanTimeInSeconds,
                                 BLINK_FROM_HERE);
   }
 
  private:
   static const unsigned presentationAttributeCacheCleanTimeInSeconds = 60;
   static const unsigned minimumPresentationAttributeCacheSizeForCleaning = 100;
   static const unsigned minimumPresentationAttributeCacheHitCountPerMinute =
       (100 * presentationAttributeCacheCleanTimeInSeconds) / 60;
 
   void cleanCache(TimerBase* timer) {
     DCHECK_EQ(timer, &m_cleanTimer);
     unsigned hitCount = m_hitCount;
     m_hitCount = 0;
     if (hitCount > minimumPresentationAttributeCacheHitCountPerMinute)
       return;
     presentationAttributeCache().clear();
   }
 
   unsigned m_hitCount;
-  Timer<PresentationAttributeCacheCleaner> m_cleanTimer;
+  TaskRunnerTimer<PresentationAttributeCacheCleaner> m_cleanTimer;
 };
 
 static bool attributeNameSort(const std::pair<StringImpl*, AtomicString>& p1,
                               const std::pair<StringImpl*, AtomicString>& p2) {
   // Sort based on the attribute name pointers. It doesn't matter what the order
   // is as long as it is always the same.
   return p1.first < p2.first;
 }
 
 static void makePresentationAttributeCacheKey(
@@ skipping 88 matching lines @@
     presentationAttributeCache().clear();
     presentationAttributeCache().set(cacheHash, newEntry);
   } else {
     cacheValue->value = newEntry;
   }
 
   return style;
 }
 
 }  // namespace blink