blob: cf4f2e901ecab5b3bb42469fac7b063daaed7ee4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
// 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 "net/dns/watching_file_reader.h"
#include "base/bind.h"
#include "base/location.h"
#include "base/message_loop.h"
#include "base/threading/worker_pool.h"
namespace net {
FilePathWatcherShim::FilePathWatcherShim()
: watcher_(new base::files::FilePathWatcher()) {}
FilePathWatcherShim::~FilePathWatcherShim() {}
bool FilePathWatcherShim::Watch(
const FilePath& path,
base::files::FilePathWatcher::Delegate* delegate) {
DCHECK(CalledOnValidThread());
return watcher_->Watch(path, delegate);
}
FilePathWatcherShim*
FilePathWatcherFactory::CreateFilePathWatcher() {
DCHECK(CalledOnValidThread());
return new FilePathWatcherShim();
}
// A FilePathWatcher::Delegate that forwards calls to the WatchingFileReader.
// This is separated out to keep WatchingFileReader strictly single-threaded.
class WatchingFileReader::WatcherDelegate
: public base::files::FilePathWatcher::Delegate {
public:
explicit WatcherDelegate(base::WeakPtr<WatchingFileReader> reader)
: reader_(reader) {}
void OnFilePathChanged(const FilePath& path) OVERRIDE {
if (reader_) reader_->OnFilePathChanged(path);
}
void OnFilePathError(const FilePath& path) OVERRIDE {
if (reader_) reader_->OnFilePathError(path);
}
private:
virtual ~WatcherDelegate() {}
base::WeakPtr<WatchingFileReader> reader_;
};
WatchingFileReader::WatchingFileReader()
: watcher_factory_(new FilePathWatcherFactory()) {}
WatchingFileReader::~WatchingFileReader() {
if (reader_)
reader_->Cancel();
}
void WatchingFileReader::StartWatch(const FilePath& path,
SerialWorker* reader) {
DCHECK(CalledOnValidThread());
DCHECK(!watcher_.get());
DCHECK(!watcher_delegate_.get());
DCHECK(path_.empty());
path_ = path;
watcher_delegate_ = new WatcherDelegate(AsWeakPtr());
reader_ = reader;
RestartWatch();
}
void WatchingFileReader::OnFilePathChanged(const FilePath& path) {
DCHECK(CalledOnValidThread());
reader_->WorkNow();
}
void WatchingFileReader::OnFilePathError(const FilePath& path) {
DCHECK(CalledOnValidThread());
RestartWatch();
}
void WatchingFileReader::RescheduleWatch() {
DCHECK(CalledOnValidThread());
MessageLoop::current()->PostDelayedTask(
FROM_HERE,
base::Bind(&WatchingFileReader::RestartWatch, AsWeakPtr()),
base::TimeDelta::FromMilliseconds(kWatchRetryDelayMs));
}
void WatchingFileReader::RestartWatch() {
DCHECK(CalledOnValidThread());
if (reader_->IsCancelled())
return;
watcher_.reset(watcher_factory_->CreateFilePathWatcher());
if (watcher_->Watch(path_, watcher_delegate_)) {
reader_->WorkNow();
} else {
LOG(WARNING) << "Watch on " <<
path_.LossyDisplayName() <<
" failed, scheduling restart";
RescheduleWatch();
}
}
} // namespace net
|
