cc: Prevent recursion in *TileTaskWorkerPool methods.

cc/base/util.h

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_BASE_UTIL_H_
 #define CC_BASE_UTIL_H_
 
 #include <limits>
 
 #include "base/basictypes.h"
+#include "base/logging.h"
 
 namespace cc {
 
 template <typename T> T RoundUp(T n, T mul) {
   COMPILE_ASSERT(std::numeric_limits<T>::is_integer, type_must_be_integral);
   return (n > 0) ? ((n + mul - 1) / mul) * mul
                  : (n / mul) * mul;
 }
 
 template <typename T> T RoundDown(T n, T mul) {
   COMPILE_ASSERT(std::numeric_limits<T>::is_integer, type_must_be_integral);
   return (n > 0) ? (n / mul) * mul
                  : (n == 0) ? 0
                  : ((n - mul + 1) / mul) * mul;
 }
 
+class ScopedSingleEntry {

[reveman, 2014/12/18 19:24:07]

This seems very similar to base::ThreadCollisionWarner. I guess you could just
use that instead but that might be confusing as it's not really checking for
thread collisions. Would be nice if usage was at least consistent with
base::ThreadCollisionWarner..

[vmiura, 2014/12/18 21:16:48]

DFAKE_SCOPED_LOCK() seems like a superset of what we need; it detects recursion,
as well as multiple thread entry.  Would you be OK if I use that?

The failure looks like:

[40382:40383:1218/131159:763931716939:FATAL:thread_collision_warner.cc(13)]
Check failed: false. Thread Collision
#0 0x0000010f55fe base::debug::StackTrace::StackTrace()
#1 0x00000113c6b5 logging::LogMessage::~LogMessage()
#2 0x0000011c40e1 base::DCheckAsserter::warn()
#3 0x0000011c41f6 base::ThreadCollisionWarner::Enter()
#4 0x000000ef76a3 base::ThreadCollisionWarner::ScopedCheck::ScopedCheck()
#5 0x000000ef5fa4 cc::PixelBufferTileTaskWorkerPool::CheckForCompletedTasks()
#6 0x000000ef64ac cc::PixelBufferTileTaskWorkerPool::CheckForCompletedTasks()
#7 0x000000f68297 cc::TileManager::CheckIfMoreTilesNeedPrepare()
#8 0x000000f69209 cc::TileManager::DidFinishRunningTileTasks()
#9 0x000000ef0ebc
cc::PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks()
#10 0x000000ef689c cc::PixelBufferTileTaskWorkerPool::OnTaskSetFinished()
#11 0x000000b62eda base::internal::RunnableAdapter<>::Run()
#12 0x000000ea20d8 base::internal::InvokeHelper<>::MakeItSo()
#13 0x000000efc88c base::internal::Invoker<>::Run()
#14 0x0000004e376e base::Callback<>::Run()

[reveman, 2014/12/19 00:03:18]

Yes, I think that's better than adding this new class. Ideally we'd have
something called a ReentryChecker in base but if ThreadCollisionWarner works I
think it's a good idea to just use that. This is only for
PixelBufferTileTaskWorkerPool, which we'll hopefully be able to remove soon
anyhow.

+ public:
+  explicit ScopedSingleEntry(bool* single_entry_holder)
+      : single_entry_holder_(single_entry_holder) {
+    DCHECK(!*single_entry_holder_);
+    *single_entry_holder_ = true;
+  }
+
+  ~ScopedSingleEntry() {
+    DCHECK(*single_entry_holder_);
+    *single_entry_holder_ = false;
+  }
+
+ private:
+  bool* single_entry_holder_;
+};
+
 }  // namespace cc
 
 #endif  // CC_BASE_UTIL_H_