blob: c669e181cef943ee6c3095cbd2af07f9204a2894 [file] [log] [blame]
// Copyright (c) 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.
#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
class BrowserProcessImpl;
class HistogramSynchronizer;
class NativeBackendKWallet;
namespace android_webview {
class AwFormDatabaseService;
class CookieManager;
namespace cc {
class CompletionEvent;
class SingleThreadTaskGraphRunner;
namespace chromeos {
class BlockingMethodCaller;
namespace system {
class StatisticsProviderImpl;
namespace chrome_browser_net {
class Predictor;
namespace content {
class BrowserGpuChannelHostFactory;
class BrowserGpuMemoryBufferManager;
class BrowserMainLoop;
class BrowserShutdownProfileDumper;
class BrowserSurfaceViewManager;
class BrowserTestBase;
class CategorizedWorkerPool;
class NestedMessagePumpAndroid;
class ScopedAllowWaitForAndroidLayoutTests;
class ScopedAllowWaitForDebugURL;
class SoftwareOutputDeviceMus;
class SynchronousCompositor;
class SynchronousCompositorBrowserFilter;
class SynchronousCompositorHost;
class TextInputClientMac;
} // namespace content
namespace dbus {
class Bus;
namespace disk_cache {
class BackendImpl;
class InFlightIO;
namespace gpu {
class GpuChannelHost;
namespace mojo {
class SyncCallRestrictions;
namespace edk {
class ScopedIPCSupport;
namespace ui {
class CommandBufferClientImpl;
class CommandBufferLocal;
class GpuState;
namespace net {
class NetworkChangeNotifierMac;
namespace internal {
class AddressTrackerLinux;
namespace remoting {
class AutoThread;
namespace ui {
class WindowResizeHelperMac;
namespace views {
class ScreenMus;
namespace viz {
class ServerGpuMemoryBufferManager;
namespace base {
namespace android {
class JavaHandlerThread;
namespace internal {
class TaskTracker;
class SequencedWorkerPool;
class SimpleThread;
class StackSamplingProfiler;
class Thread;
class ThreadTestHelper;
// Certain behavior is disallowed on certain threads. ThreadRestrictions helps
// enforce these rules. Examples of such rules:
// * Do not do blocking IO (makes the thread janky)
// * Do not access Singleton/LazyInstance (may lead to shutdown crashes)
// Here's more about how the protection works:
// 1) If a thread should not be allowed to make IO calls, mark it:
// base::ThreadRestrictions::SetIOAllowed(false);
// By default, threads *are* allowed to make IO calls.
// In Chrome browser code, IO calls should be proxied to a TaskRunner with
// the base::MayBlock() trait.
// 2) If a function makes a call that will go out to disk, check whether the
// current thread is allowed:
// base::ThreadRestrictions::AssertIOAllowed();
// Style tip: where should you put AssertIOAllowed checks? It's best
// if you put them as close to the disk access as possible, at the
// lowest level. This rule is simple to follow and helps catch all
// callers. For example, if your function GoDoSomeBlockingDiskCall()
// only calls other functions in Chrome and not fopen(), you should go
// add the AssertIOAllowed checks in the helper functions.
class BASE_EXPORT ThreadRestrictions {
// Constructing a ScopedAllowIO temporarily allows IO for the current
// thread. Doing this is almost certainly always incorrect.
class BASE_EXPORT ScopedAllowIO {
ScopedAllowIO() { previous_value_ = SetIOAllowed(true); }
~ScopedAllowIO() { SetIOAllowed(previous_value_); }
// Whether IO is allowed when the ScopedAllowIO was constructed.
bool previous_value_;
// Set whether the current thread to make IO calls.
// Threads start out in the *allowed* state.
// Returns the previous value.
static bool SetIOAllowed(bool allowed);
// Check whether the current thread is allowed to make IO calls,
// and DCHECK if not. See the block comment above the class for
// a discussion of where to add these checks.
static void AssertIOAllowed();
// Set whether the current thread can use singletons. Returns the previous
// value.
static bool SetSingletonAllowed(bool allowed);
// Check whether the current thread is allowed to use singletons (Singleton /
// LazyInstance). DCHECKs if not.
static void AssertSingletonAllowed();
// Disable waiting on the current thread. Threads start out in the *allowed*
// state. Returns the previous value.
static void DisallowWaiting();
// Check whether the current thread is allowed to wait, and DCHECK if not.
static void AssertWaitAllowed();
// Inline the empty definitions of these functions so that they can be
// compiled out.
static bool SetIOAllowed(bool allowed) { return true; }
static void AssertIOAllowed() {}
static bool SetSingletonAllowed(bool allowed) { return true; }
static void AssertSingletonAllowed() {}
static void DisallowWaiting() {}
static void AssertWaitAllowed() {}
// DO NOT ADD ANY OTHER FRIEND STATEMENTS, talk to jam or brettw first.
friend class android_webview::AwFormDatabaseService;
friend class android_webview::CookieManager;
friend class base::StackSamplingProfiler;
friend class content::BrowserMainLoop;
friend class content::BrowserShutdownProfileDumper;
friend class content::BrowserSurfaceViewManager;
friend class content::BrowserTestBase;
friend class content::NestedMessagePumpAndroid;
friend class content::ScopedAllowWaitForAndroidLayoutTests;
friend class content::ScopedAllowWaitForDebugURL;
friend class content::SynchronousCompositor;
friend class content::SynchronousCompositorBrowserFilter;
friend class content::SynchronousCompositorHost;
friend class ::HistogramSynchronizer;
friend class internal::TaskTracker;
friend class cc::CompletionEvent;
friend class cc::SingleThreadTaskGraphRunner;
friend class content::CategorizedWorkerPool;
friend class remoting::AutoThread;
friend class ui::WindowResizeHelperMac;
friend class MessagePumpDefault;
friend class SequencedWorkerPool;
friend class SimpleThread;
friend class Thread;
friend class ThreadTestHelper;
friend class PlatformThread;
friend class android::JavaHandlerThread;
friend class mojo::SyncCallRestrictions;
friend class mojo::edk::ScopedIPCSupport;
friend class ui::CommandBufferClientImpl;
friend class ui::CommandBufferLocal;
friend class ui::GpuState;
friend class ::chromeos::BlockingMethodCaller; //
friend class ::chromeos::system::StatisticsProviderImpl; //
friend class chrome_browser_net::Predictor; //
friend class
content::BrowserGpuChannelHostFactory; //
friend class
content::BrowserGpuMemoryBufferManager; //
friend class content::TextInputClientMac; //
friend class dbus::Bus; //
friend class disk_cache::BackendImpl; //
friend class disk_cache::InFlightIO; //
friend class gpu::GpuChannelHost; //
friend class net::internal::AddressTrackerLinux; //
friend class net::NetworkChangeNotifierMac; //
friend class ::BrowserProcessImpl; //
friend class ::NativeBackendKWallet; //
#if !defined(OFFICIAL_BUILD)
friend class content::SoftwareOutputDeviceMus; // Interim non-production code
friend class views::ScreenMus;
friend class viz::ServerGpuMemoryBufferManager;
static bool SetWaitAllowed(bool allowed);
static bool SetWaitAllowed(bool allowed) { return true; }
// Constructing a ScopedAllowWait temporarily allows waiting on the current
// thread. Doing this is almost always incorrect, which is why we limit who
// can use this through friend. If you find yourself needing to use this, find
// another way. Talk to jam or brettw.
class BASE_EXPORT ScopedAllowWait {
ScopedAllowWait() { previous_value_ = SetWaitAllowed(true); }
~ScopedAllowWait() { SetWaitAllowed(previous_value_); }
// Whether singleton use is allowed when the ScopedAllowWait was
// constructed.
bool previous_value_;
} // namespace base