mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-29 00:32:35 +08:00
d98690a182
This patch also updates WorkerThread to execute DoWork() when DoWorkNow() has been called, which is relevant when DoWorkNow() and Stop() have both been called. This occurs regularly on Android where the handler's current normal mode is to dump a single process and exit. This change ensures the upload thread has a chance to upload the report before the handler exits. This change should not affect upload on Chrome/WebView/Chromecast which don't pass Crashpad a --url option and are still responsible for their own uploads. Change-Id: Ie5553eafc13714f0438b4b133a92516f7abec153 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/1643710 Commit-Queue: Joshua Peraza <jperaza@chromium.org> Reviewed-by: Mark Mentovai <mark@chromium.org>
103 lines
3.5 KiB
C++
103 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_;
|
|
bool do_work_now_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(WorkerThread);
|
|
};
|
|
|
|
} // namespace crashpad
|
|
|
|
#endif // CRASHPAD_UTIL_THREAD_WORKER_THREAD_H_
|