mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-29 00:32:35 +08:00
1aa478d161
This change was partially scripted and partially done manually with vim regex + manually placing the deleted constructors. The script change looked for destructors in the public: section of a class, if that existed the deleted constructors would go before the destructor. For manual placement I looked for any constructor in the public: section of the corresponding class. If there wasn't one, then it would ideally have gone as the first entry except below enums, classes and typedefs. This may not have been perfect, but is hopefully good enough. Fingers crossed. #include "base/macros.h" is removed from files that don't use ignore_result, which is the only other thing defined in base/macros.h. Bug: chromium:1010217 Change-Id: I099526255a40b1ac1264904b4ece2f3f503c9418 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/3171034 Reviewed-by: Mark Mentovai <mark@chromium.org> Commit-Queue: Peter Boström <pbos@chromium.org>
102 lines
3.8 KiB
C++
102 lines
3.8 KiB
C++
// Copyright 2014 The Crashpad Authors. All rights reserved.
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// http://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
|
||
#ifndef CRASHPAD_UTIL_MISC_INITIALIZATION_INITIALIZATION_STATE_H_
|
||
#define CRASHPAD_UTIL_MISC_INITIALIZATION_INITIALIZATION_STATE_H_
|
||
|
||
#include <stdint.h>
|
||
|
||
|
||
namespace crashpad {
|
||
|
||
//! \brief Tracks whether data are initialized.
|
||
//!
|
||
//! Objects of this type track whether the data they’re guarding are
|
||
//! initialized. The three possible states are uninitialized (the initial
|
||
//! state), initializing, and valid. As the guarded data are initialized, an
|
||
//! InitializationState object will normally transition through these three
|
||
//! states. A fourth state corresponds to the destruction of objects of this
|
||
//! type, making it less likely that a use-after-free of an InitializationState
|
||
//! object will appear in the valid state.
|
||
//!
|
||
//! If the only purpose for tracking the initialization state of guarded data is
|
||
//! to DCHECK when the object is in an unexpected state, use
|
||
//! InitializationStateDcheck instead.
|
||
class InitializationState {
|
||
public:
|
||
//! \brief The object’s state.
|
||
enum State : uint8_t {
|
||
//! \brief The object has not yet been initialized.
|
||
kStateUninitialized = 0,
|
||
|
||
//! \brief The object is being initialized.
|
||
//!
|
||
//! This state protects against attempted reinitializaton of
|
||
//! partially-initialized objects whose initial initialization attempt
|
||
//! failed. This state is to be used while objects are initializing, but are
|
||
//! not yet fully initialized.
|
||
kStateInvalid,
|
||
|
||
//! \brief The object has been initialized.
|
||
kStateValid,
|
||
|
||
//! \brief The object has been destroyed.
|
||
kStateDestroyed,
|
||
};
|
||
|
||
InitializationState() : state_(kStateUninitialized) {}
|
||
|
||
InitializationState(const InitializationState&) = delete;
|
||
InitializationState& operator=(const InitializationState&) = delete;
|
||
|
||
~InitializationState() { state_ = kStateDestroyed; }
|
||
|
||
//! \brief Returns `true` if the object’s state is #kStateUninitialized and it
|
||
//! is safe to begin initializing it.
|
||
bool is_uninitialized() const { return state_ == kStateUninitialized; }
|
||
|
||
//! \brief Sets the object’s state to #kStateInvalid, marking initialization
|
||
//! as being in process.
|
||
void set_invalid() { state_ = kStateInvalid; }
|
||
|
||
//! \brief Sets the object’s state to #kStateValid, marking it initialized.
|
||
void set_valid() { state_ = kStateValid; }
|
||
|
||
//! \brief Returns `true` if the the object’s state is #kStateValid and it has
|
||
//! been fully initialized and may be used.
|
||
bool is_valid() const { return state_ == kStateValid; }
|
||
|
||
protected:
|
||
//! \brief Returns the object’s state.
|
||
//!
|
||
//! Consumers of this class should use an is_state_*() method instead.
|
||
State state() const { return state_; }
|
||
|
||
//! \brief Sets the object’s state.
|
||
//!
|
||
//! Consumers of this class should use a set_state_*() method instead.
|
||
void set_state(State state) { state_ = state; }
|
||
|
||
private:
|
||
// state_ is volatile to ensure that it’ll be set by the destructor when it
|
||
// runs. Otherwise, optimizations might prevent it from ever being set to
|
||
// kStateDestroyed, limiting this class’ ability to catch use-after-free
|
||
// errors.
|
||
volatile State state_;
|
||
};
|
||
|
||
} // namespace crashpad
|
||
|
||
#endif // CRASHPAD_UTIL_MISC_INITIALIZATION_INITIALIZATION_STATE_H_
|