0

Remove storage::TimedTaskHelper.

All uses have been replaced with the well-maintained base::Timer.

TBR=kinuko@chromium.org

Bug: 760326
Change-Id: I1542f0f03de11961e67ef4447966dd145327f886
Reviewed-on: https://chromium-review.googlesource.com/1012741
Commit-Queue: François Doray <fdoray@chromium.org>
Reviewed-by: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#551681}
This commit is contained in:
Francois Doray
2018-04-18 15:19:58 +00:00
committed by Commit Bot
parent 2e9f39badf
commit cdfc0892d6
4 changed files with 0 additions and 243 deletions

@ -166,8 +166,6 @@ component("browser") {
"fileapi/sandbox_quota_observer.cc",
"fileapi/sandbox_quota_observer.h",
"fileapi/task_runner_bound_observer_list.h",
"fileapi/timed_task_helper.cc",
"fileapi/timed_task_helper.h",
"fileapi/transient_file_util.cc",
"fileapi/transient_file_util.h",
"fileapi/watcher_manager.h",
@ -292,7 +290,6 @@ source_set("unittests") {
"fileapi/sandbox_isolated_origin_database_unittest.cc",
"fileapi/sandbox_origin_database_unittest.cc",
"fileapi/sandbox_prioritized_origin_database_unittest.cc",
"fileapi/timed_task_helper_unittest.cc",
"fileapi/transient_file_util_unittest.cc",
"quota/quota_database_unittest.cc",
"quota/quota_manager_unittest.cc",

@ -1,93 +0,0 @@
// Copyright 2013 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 "storage/browser/fileapi/timed_task_helper.h"
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/sequenced_task_runner.h"
namespace storage {
struct TimedTaskHelper::Tracker {
explicit Tracker(TimedTaskHelper* timer) : timer(timer) {}
~Tracker() {
if (timer)
timer->tracker_ = NULL;
}
TimedTaskHelper* timer;
};
TimedTaskHelper::TimedTaskHelper(base::SequencedTaskRunner* task_runner)
: task_runner_(task_runner),
tracker_(NULL) {
}
TimedTaskHelper::~TimedTaskHelper() {
if (tracker_)
tracker_->timer = NULL;
}
bool TimedTaskHelper::IsRunning() const {
DCHECK(task_runner_->RunsTasksInCurrentSequence());
return tracker_ != NULL;
}
void TimedTaskHelper::Start(const base::Location& posted_from,
base::TimeDelta delay,
const base::Closure& user_task) {
posted_from_ = posted_from;
delay_ = delay;
user_task_ = user_task;
Reset();
}
void TimedTaskHelper::Reset() {
DCHECK(task_runner_->RunsTasksInCurrentSequence());
DCHECK(!user_task_.is_null());
desired_run_time_ = base::TimeTicks::Now() + delay_;
if (tracker_)
return;
// Initialize the tracker for the first time.
tracker_ = new Tracker(this);
PostDelayedTask(base::WrapUnique(tracker_), delay_);
}
// static
void TimedTaskHelper::Fired(std::unique_ptr<Tracker> tracker) {
if (!tracker->timer)
return;
TimedTaskHelper* timer = tracker->timer;
timer->OnFired(std::move(tracker));
}
void TimedTaskHelper::OnFired(std::unique_ptr<Tracker> tracker) {
DCHECK(task_runner_->RunsTasksInCurrentSequence());
base::TimeTicks now = base::TimeTicks::Now();
if (desired_run_time_ > now) {
PostDelayedTask(std::move(tracker), desired_run_time_ - now);
return;
}
tracker.reset();
base::Closure task = user_task_;
user_task_.Reset();
task.Run();
}
void TimedTaskHelper::PostDelayedTask(std::unique_ptr<Tracker> tracker,
base::TimeDelta delay) {
task_runner_->PostDelayedTask(
posted_from_, base::BindOnce(&TimedTaskHelper::Fired, std::move(tracker)),
delay);
}
} // namespace storage

@ -1,60 +0,0 @@
// Copyright 2013 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 STORAGE_BROWSER_FILEAPI_TIMED_TASK_HELPER_H_
#define STORAGE_BROWSER_FILEAPI_TIMED_TASK_HELPER_H_
#include <memory>
#include "base/callback.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/time/time.h"
#include "storage/browser/storage_browser_export.h"
namespace base {
class SequencedTaskRunner;
}
namespace storage {
// Works similarly as base::Timer, but takes SequencedTaskRunner and
// runs tasks on it (instead of implicitly bound to a thread).
// TODO(kinuko): This has nothing to do with fileapi. Move somewhere
// more common place.
class STORAGE_EXPORT TimedTaskHelper {
public:
explicit TimedTaskHelper(base::SequencedTaskRunner* task_runner);
~TimedTaskHelper();
bool IsRunning() const;
void Start(const base::Location& posted_from,
base::TimeDelta delay,
const base::Closure& user_task);
void Reset();
private:
struct Tracker;
static void Fired(std::unique_ptr<Tracker> tracker);
void OnFired(std::unique_ptr<Tracker> tracker);
void PostDelayedTask(std::unique_ptr<Tracker> tracker, base::TimeDelta delay);
scoped_refptr<base::SequencedTaskRunner> task_runner_;
base::Location posted_from_;
base::TimeDelta delay_;
base::Closure user_task_;
base::TimeTicks desired_run_time_;
// This is set to non-null and owned by a timer task while timer is running.
Tracker* tracker_;
DISALLOW_COPY_AND_ASSIGN(TimedTaskHelper);
};
} // namespace storage
#endif // STORAGE_BROWSER_FILEAPI_TIMED_TASK_HELPER_H_

@ -1,87 +0,0 @@
// Copyright 2014 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 <memory>
#include "base/bind.h"
#include "base/location.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "storage/browser/fileapi/timed_task_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
using storage::TimedTaskHelper;
namespace content {
namespace {
class Embedder {
public:
Embedder()
: timer_(base::ThreadTaskRunnerHandle::Get().get()),
timer_fired_(false) {}
void OnTimerFired() {
timer_fired_ = true;
}
TimedTaskHelper* timer() { return &timer_; }
bool timer_fired() const { return timer_fired_; }
private:
TimedTaskHelper timer_;
bool timer_fired_;
};
} // namespace
TEST(TimedTaskHelper, FireTimerWhenAlive) {
base::MessageLoop message_loop;
Embedder embedder;
ASSERT_FALSE(embedder.timer_fired());
ASSERT_FALSE(embedder.timer()->IsRunning());
embedder.timer()->Start(
FROM_HERE,
base::TimeDelta::FromSeconds(0),
base::Bind(&Embedder::OnTimerFired, base::Unretained(&embedder)));
ASSERT_TRUE(embedder.timer()->IsRunning());
embedder.timer()->Reset();
ASSERT_TRUE(embedder.timer()->IsRunning());
base::RunLoop().RunUntilIdle();
ASSERT_TRUE(embedder.timer_fired());
}
TEST(TimedTaskHelper, FireTimerWhenAlreadyDeleted) {
base::MessageLoop message_loop;
// Run message loop after embedder is already deleted to make sure callback
// doesn't cause a crash for use after free.
{
Embedder embedder;
ASSERT_FALSE(embedder.timer_fired());
ASSERT_FALSE(embedder.timer()->IsRunning());
embedder.timer()->Start(
FROM_HERE,
base::TimeDelta::FromSeconds(0),
base::Bind(&Embedder::OnTimerFired, base::Unretained(&embedder)));
ASSERT_TRUE(embedder.timer()->IsRunning());
}
// At this point the callback is still in the message queue but
// embedder is gone.
base::RunLoop().RunUntilIdle();
}
} // namespace content