mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-29 00:32:35 +08:00
8297b19a5e
76a67a37b1d0 adds crashpad_handler’s --monitor-self argument, which results in a second crashpad_handler instance running out of the same database as the initial crashpad_handler instance that it monitors. The two handlers start at nearly the same time, and will initially be on precisely the same schedule for periodic tasks such as scanning for new reports to upload and pruning the database. This is an unnecessary duplication of effort. This adds a new --no-periodic-tasks argument to crashpad_handler. When the first instance of crashpad_handler starts a second to monitor it, it will use this argument, which prevents the second instance from performing these tasks. When --no-periodic-tasks is in effect, crashpad_handler will still be able to upload crash reports that it knows about by virtue of having written them itself, but it will not scan the database for other pending reports to upload. Bug: crashpad:143 Test: crashpad_util_test ThreadSafeVector.ThreadSafeVector Change-Id: I7b249dd7b6d5782448d8071855818f986b98ab5a Reviewed-on: https://chromium-review.googlesource.com/473827 Reviewed-by: Robert Sesek <rsesek@chromium.org>
102 lines
3.5 KiB
C++
102 lines
3.5 KiB
C++
// Copyright 2015 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_THREAD_WORKER_THREAD_H_
|
|
#define CRASHPAD_UTIL_THREAD_WORKER_THREAD_H_
|
|
|
|
#include <memory>
|
|
|
|
#include "base/macros.h"
|
|
#include "util/synchronization/semaphore.h"
|
|
|
|
namespace crashpad {
|
|
|
|
namespace internal {
|
|
class WorkerThreadImpl;
|
|
} // namespace internal
|
|
|
|
//! \brief A WorkerThread executes its Delegate's DoWork method repeatedly on a
|
|
//! dedicated thread at a set time interval.
|
|
class WorkerThread {
|
|
public:
|
|
//! \brief An interface for doing work on a WorkerThread.
|
|
class Delegate {
|
|
public:
|
|
//! \brief The work function executed by the WorkerThread every work
|
|
//! interval.
|
|
virtual void DoWork(const WorkerThread* thread) = 0;
|
|
|
|
protected:
|
|
virtual ~Delegate() {}
|
|
};
|
|
|
|
//! \brief A delay or interval argument that causes an indefinite wait.
|
|
static constexpr double kIndefiniteWait = Semaphore::kIndefiniteWait;
|
|
|
|
//! \brief Creates a new WorkerThread that is not yet running.
|
|
//!
|
|
//! \param[in] work_interval The time interval in seconds at which the \a
|
|
//! delegate runs. The interval counts from the completion of
|
|
//! Delegate::DoWork() to the next invocation. This can be
|
|
//! #kIndefiniteWait if work should only be done when DoWorkNow() is
|
|
//! called.
|
|
//! \param[in] delegate The work delegate to invoke every interval.
|
|
WorkerThread(double work_interval, Delegate* delegate);
|
|
~WorkerThread();
|
|
|
|
//! \brief Starts the worker thread.
|
|
//!
|
|
//! This may not be called if the thread is_running().
|
|
//!
|
|
//! \param[in] initial_work_delay The amount of time in seconds to wait
|
|
//! before invoking the \a delegate for the first time. Pass `0` for
|
|
//! no delay. This can be #kIndefiniteWait if work should not be done
|
|
//! until DoWorkNow() is called.
|
|
void Start(double initial_work_delay);
|
|
|
|
//! \brief Stops the worker thread from running.
|
|
//!
|
|
//! This may only be called if the thread is_running().
|
|
//!
|
|
//! If the work function is currently executing, this will not interrupt it.
|
|
//! This method stops any future work from occurring. This method is safe
|
|
//! to call from any thread with the exception of the worker thread itself,
|
|
//! as this joins the thread.
|
|
void Stop();
|
|
|
|
//! \brief Interrupts a \a work_interval to execute the work function
|
|
//! immediately. This invokes Delegate::DoWork() on the thread, without
|
|
//! waiting for the current \a work_interval to expire. After the
|
|
//! delegate is invoked, the WorkerThread will start waiting for a new
|
|
//! \a work_interval.
|
|
void DoWorkNow();
|
|
|
|
//! \return `true` if the thread is running, `false` if it is not.
|
|
bool is_running() const { return running_; }
|
|
|
|
private:
|
|
friend class internal::WorkerThreadImpl;
|
|
|
|
double work_interval_;
|
|
Delegate* delegate_; // weak
|
|
std::unique_ptr<internal::WorkerThreadImpl> impl_;
|
|
bool running_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(WorkerThread);
|
|
};
|
|
|
|
} // namespace crashpad
|
|
|
|
#endif // CRASHPAD_UTIL_THREAD_WORKER_THREAD_H_
|