OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ios/chrome/browser/reading_list/reading_list_entry.h" | 5 #include "ios/chrome/browser/reading_list/reading_list_entry.h" |
6 | 6 |
7 #include "base/json/json_string_value_serializer.h" | |
7 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "ios/chrome/browser/reading_list/proto/reading_list.pb.h" | |
10 #include "net/base/backoff_entry_serializer.h" | |
11 | |
12 namespace { | |
13 // Default Tick clock for |net::BackoffEntry|. | |
14 base::TickClock* ReadingListTickClock() { | |
15 static base::DefaultTickClock clock; | |
sdefresne
2016/10/07 09:44:30
This is not thread-safe when building Chromium cod
| |
16 return &clock; | |
17 } | |
18 } | |
8 | 19 |
9 // The backoff time is the following: 10min, 10min, 1h, 2h, 2h..., starting | 20 // The backoff time is the following: 10min, 10min, 1h, 2h, 2h..., starting |
10 // after the first failure. | 21 // after the first failure. |
11 const net::BackoffEntry::Policy ReadingListEntry::kBackoffPolicy = { | 22 const net::BackoffEntry::Policy ReadingListEntry::kBackoffPolicy = { |
12 // Number of initial errors (in sequence) to ignore before applying | 23 // Number of initial errors (in sequence) to ignore before applying |
13 // exponential back-off rules. | 24 // exponential back-off rules. |
14 2, | 25 2, |
15 | 26 |
16 // Initial delay for exponential back-off in ms. | 27 // Initial delay for exponential back-off in ms. |
17 10 * 60 * 1000, // 10 minutes. | 28 10 * 60 * 1000, // 10 minutes. |
(...skipping 14 matching lines...) Expand all Loading... | |
32 | 43 |
33 true, // Don't use initial delay unless the last request was an error. | 44 true, // Don't use initial delay unless the last request was an error. |
34 }; | 45 }; |
35 | 46 |
36 ReadingListEntry::ReadingListEntry(const GURL& url, const std::string& title) | 47 ReadingListEntry::ReadingListEntry(const GURL& url, const std::string& title) |
37 : ReadingListEntry(url, title, nullptr){}; | 48 : ReadingListEntry(url, title, nullptr){}; |
38 | 49 |
39 ReadingListEntry::ReadingListEntry(const GURL& url, | 50 ReadingListEntry::ReadingListEntry(const GURL& url, |
40 const std::string& title, | 51 const std::string& title, |
41 std::unique_ptr<net::BackoffEntry> backoff) | 52 std::unique_ptr<net::BackoffEntry> backoff) |
53 : ReadingListEntry(url, title, 0, 0, WAITING, GURL(), std::move(backoff)) {} | |
54 | |
55 ReadingListEntry::ReadingListEntry( | |
56 const GURL& url, | |
57 const std::string& title, | |
58 int64_t creation_time, | |
59 int64_t update_time, | |
60 ReadingListEntry::DistillationState distilled_state, | |
61 const GURL& distilled_url, | |
62 std::unique_ptr<net::BackoffEntry> backoff) | |
42 : url_(url), | 63 : url_(url), |
43 title_(title), | 64 title_(title), |
44 distilled_state_(WAITING), | 65 distilled_url_(distilled_url), |
45 failed_download_counter_(0) { | 66 distilled_state_(distilled_state), |
67 failed_download_counter_(0), | |
68 creation_time_us_(creation_time), | |
69 update_time_us_(update_time) { | |
46 if (backoff) { | 70 if (backoff) { |
47 backoff_ = std::move(backoff); | 71 backoff_ = std::move(backoff); |
48 } else { | 72 } else { |
49 backoff_ = base::MakeUnique<net::BackoffEntry>(&kBackoffPolicy); | 73 backoff_ = base::MakeUnique<net::BackoffEntry>(&kBackoffPolicy, |
74 ReadingListTickClock()); | |
75 } | |
76 if (creation_time_us_ == 0) { | |
77 DCHECK(update_time_us_ == 0); | |
78 creation_time_us_ = | |
79 (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds(); | |
80 update_time_us_ = creation_time_us_; | |
50 } | 81 } |
51 DCHECK(!url.is_empty()); | 82 DCHECK(!url.is_empty()); |
52 DCHECK(url.is_valid()); | 83 DCHECK(url.is_valid()); |
53 } | 84 } |
54 | 85 |
55 ReadingListEntry::ReadingListEntry(ReadingListEntry&& entry) | 86 ReadingListEntry::ReadingListEntry(ReadingListEntry&& entry) |
56 : url_(std::move(entry.url_)), | 87 : url_(std::move(entry.url_)), |
57 title_(std::move(entry.title_)), | 88 title_(std::move(entry.title_)), |
58 distilled_url_(std::move(entry.distilled_url_)), | 89 distilled_url_(std::move(entry.distilled_url_)), |
59 distilled_state_(std::move(entry.distilled_state_)), | 90 distilled_state_(std::move(entry.distilled_state_)), |
60 backoff_(std::move(entry.backoff_)), | 91 backoff_(std::move(entry.backoff_)), |
61 failed_download_counter_(std::move(entry.failed_download_counter_)) {} | 92 failed_download_counter_(std::move(entry.failed_download_counter_)), |
93 creation_time_us_(std::move(entry.creation_time_us_)), | |
94 update_time_us_(std::move(entry.update_time_us_)) {} | |
62 | 95 |
63 ReadingListEntry::~ReadingListEntry() {} | 96 ReadingListEntry::~ReadingListEntry() {} |
64 | 97 |
65 const GURL& ReadingListEntry::URL() const { | 98 const GURL& ReadingListEntry::URL() const { |
66 return url_; | 99 return url_; |
67 } | 100 } |
68 | 101 |
69 const std::string& ReadingListEntry::Title() const { | 102 const std::string& ReadingListEntry::Title() const { |
70 return title_; | 103 return title_; |
71 } | 104 } |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
119 // non-error state to an error state. | 152 // non-error state to an error state. |
120 if ((distilled_state == WILL_RETRY || distilled_state == ERROR) && | 153 if ((distilled_state == WILL_RETRY || distilled_state == ERROR) && |
121 distilled_state_ != WILL_RETRY && distilled_state_ != ERROR) { | 154 distilled_state_ != WILL_RETRY && distilled_state_ != ERROR) { |
122 backoff_->InformOfRequest(false); | 155 backoff_->InformOfRequest(false); |
123 failed_download_counter_++; | 156 failed_download_counter_++; |
124 } | 157 } |
125 | 158 |
126 distilled_state_ = distilled_state; | 159 distilled_state_ = distilled_state; |
127 distilled_url_ = GURL(); | 160 distilled_url_ = GURL(); |
128 } | 161 } |
162 | |
163 int64_t ReadingListEntry::UpdateTime() const { | |
164 return update_time_us_; | |
165 } | |
166 | |
167 void ReadingListEntry::MarkEntryUpdated() { | |
168 update_time_us_ = | |
169 (base::Time::Now() - base::Time::UnixEpoch()).InMicroseconds(); | |
170 } | |
171 | |
172 // static | |
173 std::unique_ptr<ReadingListEntry> ReadingListEntry::FromReadingListLocal( | |
174 const reading_list::ReadingListLocal& pb_entry) { | |
175 if (!pb_entry.has_entry() || !pb_entry.entry().has_url()) { | |
176 return nullptr; | |
177 } | |
178 GURL url(pb_entry.entry().url()); | |
179 if (url.is_empty() || !url.is_valid()) { | |
180 return nullptr; | |
181 } | |
182 std::string title; | |
183 if (pb_entry.entry().has_title()) { | |
184 title = pb_entry.entry().title(); | |
185 } | |
186 | |
187 int64_t creation_time_us = 0; | |
188 if (pb_entry.entry().has_creation_time_us()) { | |
189 creation_time_us = pb_entry.entry().creation_time_us(); | |
190 } | |
191 | |
192 int64_t update_time_us = 0; | |
193 if (pb_entry.entry().has_update_time_us()) { | |
194 update_time_us = pb_entry.entry().update_time_us(); | |
195 } | |
196 | |
197 ReadingListEntry::DistillationState distillation_state = | |
198 ReadingListEntry::WAITING; | |
199 if (pb_entry.has_distillation_state()) { | |
200 switch (pb_entry.distillation_state()) { | |
201 case reading_list::ReadingListLocal::WAITING: | |
202 distillation_state = ReadingListEntry::WAITING; | |
203 case reading_list::ReadingListLocal::PROCESSING: | |
204 distillation_state = ReadingListEntry::PROCESSING; | |
205 case reading_list::ReadingListLocal::PROCESSED: | |
206 distillation_state = ReadingListEntry::PROCESSED; | |
207 case reading_list::ReadingListLocal::WILL_RETRY: | |
208 distillation_state = ReadingListEntry::WILL_RETRY; | |
209 case reading_list::ReadingListLocal::ERROR: | |
210 distillation_state = ReadingListEntry::ERROR; | |
211 } | |
212 } | |
213 | |
214 GURL distilled_url; | |
215 if (pb_entry.has_distilled_url()) { | |
216 distilled_url = GURL(pb_entry.distilled_url()); | |
217 } | |
218 | |
219 std::unique_ptr<net::BackoffEntry> backoff; | |
220 if (pb_entry.has_backoff()) { | |
221 JSONStringValueDeserializer deserializer(pb_entry.backoff()); | |
222 std::unique_ptr<base::Value> value( | |
223 deserializer.Deserialize(nullptr, nullptr)); | |
224 if (value) { | |
225 backoff = net::BackoffEntrySerializer::DeserializeFromValue( | |
226 *value, &kBackoffPolicy, ReadingListTickClock(), base::Time::Now()); | |
227 } | |
228 } | |
229 | |
230 return base::WrapUnique<ReadingListEntry>(new ReadingListEntry( | |
231 url, title, creation_time_us, update_time_us, distillation_state, | |
232 distilled_url, std::move(backoff))); | |
233 } | |
234 | |
235 std::unique_ptr<reading_list::ReadingListLocal> | |
236 ReadingListEntry::AsReadingListLocal(bool read) const { | |
237 std::unique_ptr<reading_list::ReadingListLocal> pb_entry = | |
238 base::MakeUnique<reading_list::ReadingListLocal>(); | |
239 | |
240 // URL is used as the key for the database and sync as there is only one entry | |
241 // per URL. | |
242 pb_entry->mutable_entry()->set_entry_id(URL().spec()); | |
243 pb_entry->mutable_entry()->set_title(Title()); | |
244 pb_entry->mutable_entry()->set_url(URL().spec()); | |
245 DCHECK(creation_time_us_ > 100000000); | |
sdefresne
2016/10/07 09:44:30
Why this DCHECK? What does it mean. What does 1000
| |
246 pb_entry->mutable_entry()->set_creation_time_us(creation_time_us_); | |
247 pb_entry->mutable_entry()->set_update_time_us(UpdateTime()); | |
248 | |
249 if (read) { | |
250 pb_entry->mutable_entry()->set_status(sync_pb::ReadingListSpecifics::READ); | |
251 } else { | |
252 pb_entry->mutable_entry()->set_status( | |
253 sync_pb::ReadingListSpecifics::UNREAD); | |
254 } | |
255 | |
256 reading_list::ReadingListLocal::DistillationState distilation_state; | |
257 switch (DistilledState()) { | |
258 case ReadingListEntry::WAITING: | |
259 distilation_state = reading_list::ReadingListLocal::WAITING; | |
260 case ReadingListEntry::PROCESSING: | |
261 distilation_state = reading_list::ReadingListLocal::PROCESSING; | |
262 case ReadingListEntry::PROCESSED: | |
263 distilation_state = reading_list::ReadingListLocal::PROCESSED; | |
264 case ReadingListEntry::WILL_RETRY: | |
265 distilation_state = reading_list::ReadingListLocal::WILL_RETRY; | |
266 case ReadingListEntry::ERROR: | |
267 distilation_state = reading_list::ReadingListLocal::ERROR; | |
268 } | |
269 pb_entry->set_distillation_state(distilation_state); | |
270 if (DistilledURL().is_valid()) { | |
271 pb_entry->set_distilled_url(DistilledURL().spec()); | |
272 } | |
273 | |
274 if (backoff_) { | |
275 std::unique_ptr<base::Value> backoff = | |
276 net::BackoffEntrySerializer::SerializeToValue(*backoff_, | |
277 base::Time::Now()); | |
278 | |
279 std::string output; | |
280 JSONStringValueSerializer serializer(&output); | |
281 serializer.Serialize(*backoff); | |
282 pb_entry->set_backoff(output); | |
283 } | |
284 return pb_entry; | |
285 } | |
286 | |
287 bool ReadingListEntry::CompareEntryUpdateTime(const ReadingListEntry& lhs, | |
288 const ReadingListEntry& rhs) { | |
289 return lhs.UpdateTime() > rhs.UpdateTime(); | |
290 } | |
OLD | NEW |