extension_throttle_unittest.cc 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <memory>
  5. #include "base/strings/string_number_conversions.h"
  6. #include "base/time/time.h"
  7. #include "extensions/renderer/extension_throttle_entry.h"
  8. #include "extensions/renderer/extension_throttle_manager.h"
  9. #include "extensions/renderer/extension_throttle_test_support.h"
  10. #include "net/url_request/redirect_info.h"
  11. #include "services/network/public/mojom/url_response_head.mojom.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. using base::TimeTicks;
  14. using net::BackoffEntry;
  15. namespace extensions {
  16. namespace {
  17. class MockExtensionThrottleEntry : public ExtensionThrottleEntry {
  18. public:
  19. MockExtensionThrottleEntry()
  20. : ExtensionThrottleEntry(std::string()),
  21. backoff_entry_(&backoff_policy_, &fake_clock_) {
  22. InitPolicy();
  23. }
  24. MockExtensionThrottleEntry(const TimeTicks& exponential_backoff_release_time,
  25. const TimeTicks& sliding_window_release_time,
  26. const TimeTicks& fake_now)
  27. : ExtensionThrottleEntry(std::string()),
  28. fake_clock_(fake_now),
  29. backoff_entry_(&backoff_policy_, &fake_clock_) {
  30. InitPolicy();
  31. set_exponential_backoff_release_time(exponential_backoff_release_time);
  32. set_sliding_window_release_time(sliding_window_release_time);
  33. }
  34. ~MockExtensionThrottleEntry() override {}
  35. void InitPolicy() {
  36. // Some tests become flaky if we have jitter.
  37. backoff_policy_.jitter_factor = 0.0;
  38. // This lets us avoid having to make multiple failures initially (this
  39. // logic is already tested in the BackoffEntry unit tests).
  40. backoff_policy_.num_errors_to_ignore = 0;
  41. }
  42. const BackoffEntry* GetBackoffEntry() const override {
  43. return &backoff_entry_;
  44. }
  45. BackoffEntry* GetBackoffEntry() override { return &backoff_entry_; }
  46. void ResetToBlank(const TimeTicks& time_now) {
  47. fake_clock_.set_now(time_now);
  48. GetBackoffEntry()->Reset();
  49. set_sliding_window_release_time(time_now);
  50. }
  51. // Overridden for tests.
  52. TimeTicks ImplGetTimeNow() const override { return fake_clock_.NowTicks(); }
  53. void set_fake_now(const TimeTicks& now) { fake_clock_.set_now(now); }
  54. void set_exponential_backoff_release_time(const TimeTicks& release_time) {
  55. GetBackoffEntry()->SetCustomReleaseTime(release_time);
  56. }
  57. TimeTicks sliding_window_release_time() const {
  58. return ExtensionThrottleEntry::sliding_window_release_time();
  59. }
  60. void set_sliding_window_release_time(const TimeTicks& release_time) {
  61. ExtensionThrottleEntry::set_sliding_window_release_time(release_time);
  62. }
  63. private:
  64. mutable TestTickClock fake_clock_;
  65. BackoffEntry backoff_entry_;
  66. };
  67. class MockExtensionThrottleManager : public ExtensionThrottleManager {
  68. public:
  69. MockExtensionThrottleManager() : create_entry_index_(0) {}
  70. std::string GetIdFromUrl(const GURL& url) const {
  71. return ExtensionThrottleManager::GetIdFromUrl(url);
  72. }
  73. ExtensionThrottleEntry* RegisterRequestUrl(const GURL& url) {
  74. return ExtensionThrottleManager::RegisterRequestUrl(url);
  75. }
  76. void GarbageCollectEntries() {
  77. ExtensionThrottleManager::GarbageCollectEntries();
  78. }
  79. // Returns the number of entries in the map.
  80. int GetNumberOfEntries() const { return GetNumberOfEntriesForTests(); }
  81. void CreateEntry(bool is_outdated) {
  82. TimeTicks time = TimeTicks::Now();
  83. if (is_outdated) {
  84. time -= base::Milliseconds(
  85. MockExtensionThrottleEntry::kDefaultEntryLifetimeMs + 1000);
  86. }
  87. std::string fake_url_string("http://www.fakeurl.com/");
  88. fake_url_string.append(base::NumberToString(create_entry_index_++));
  89. GURL fake_url(fake_url_string);
  90. OverrideEntryForTests(fake_url,
  91. std::make_unique<MockExtensionThrottleEntry>(
  92. time, TimeTicks::Now(), TimeTicks::Now()));
  93. }
  94. private:
  95. int create_entry_index_;
  96. };
  97. struct TimeAndBool {
  98. TimeAndBool(const TimeTicks& time_value, bool expected, int line_num) {
  99. time = time_value;
  100. result = expected;
  101. line = line_num;
  102. }
  103. TimeTicks time;
  104. bool result;
  105. int line;
  106. };
  107. struct GurlAndString {
  108. GurlAndString(const GURL& url_value,
  109. const std::string& expected,
  110. int line_num) {
  111. url = url_value;
  112. result = expected;
  113. line = line_num;
  114. }
  115. GURL url;
  116. std::string result;
  117. int line;
  118. };
  119. } // namespace
  120. class ExtensionThrottleEntryTest : public testing::Test {
  121. protected:
  122. ExtensionThrottleEntryTest() = default;
  123. void SetUp() override;
  124. TimeTicks now_;
  125. MockExtensionThrottleManager manager_; // Dummy object, not used.
  126. std::unique_ptr<MockExtensionThrottleEntry> entry_;
  127. };
  128. void ExtensionThrottleEntryTest::SetUp() {
  129. now_ = TimeTicks::Now();
  130. entry_ = std::make_unique<MockExtensionThrottleEntry>();
  131. entry_->ResetToBlank(now_);
  132. }
  133. TEST_F(ExtensionThrottleEntryTest, CanThrottleRequest) {
  134. entry_->set_exponential_backoff_release_time(entry_->ImplGetTimeNow() +
  135. base::Milliseconds(1));
  136. EXPECT_TRUE(entry_->ShouldRejectRequest());
  137. }
  138. TEST_F(ExtensionThrottleEntryTest,
  139. CanThrottleRequestNotDuringExponentialBackoff) {
  140. entry_->set_exponential_backoff_release_time(entry_->ImplGetTimeNow());
  141. EXPECT_FALSE(entry_->ShouldRejectRequest());
  142. entry_->set_exponential_backoff_release_time(entry_->ImplGetTimeNow() -
  143. base::Milliseconds(1));
  144. EXPECT_FALSE(entry_->ShouldRejectRequest());
  145. }
  146. TEST_F(ExtensionThrottleEntryTest, InterfaceUpdateFailure) {
  147. entry_->UpdateWithResponse(503);
  148. EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(),
  149. entry_->ImplGetTimeNow())
  150. << "A failure should increase the release_time";
  151. }
  152. TEST_F(ExtensionThrottleEntryTest, InterfaceUpdateSuccess) {
  153. entry_->UpdateWithResponse(200);
  154. EXPECT_EQ(entry_->GetExponentialBackoffReleaseTime(),
  155. entry_->ImplGetTimeNow())
  156. << "A success should not add any delay";
  157. }
  158. TEST_F(ExtensionThrottleEntryTest, InterfaceUpdateSuccessThenFailure) {
  159. entry_->UpdateWithResponse(200);
  160. entry_->UpdateWithResponse(503);
  161. EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(),
  162. entry_->ImplGetTimeNow())
  163. << "This scenario should add delay";
  164. entry_->UpdateWithResponse(200);
  165. }
  166. TEST_F(ExtensionThrottleEntryTest, IsEntryReallyOutdated) {
  167. base::TimeDelta lifetime =
  168. base::Milliseconds(MockExtensionThrottleEntry::kDefaultEntryLifetimeMs);
  169. const base::TimeDelta kFiveMs = base::Milliseconds(5);
  170. TimeAndBool test_values[] = {
  171. TimeAndBool(now_, false, __LINE__),
  172. TimeAndBool(now_ - kFiveMs, false, __LINE__),
  173. TimeAndBool(now_ + kFiveMs, false, __LINE__),
  174. TimeAndBool(now_ - (lifetime - kFiveMs), false, __LINE__),
  175. TimeAndBool(now_ - lifetime, true, __LINE__),
  176. TimeAndBool(now_ - (lifetime + kFiveMs), true, __LINE__)};
  177. for (unsigned int i = 0; i < std::size(test_values); ++i) {
  178. entry_->set_exponential_backoff_release_time(test_values[i].time);
  179. EXPECT_EQ(entry_->IsEntryOutdated(), test_values[i].result)
  180. << "Test case #" << i << " line " << test_values[i].line << " failed";
  181. }
  182. }
  183. TEST_F(ExtensionThrottleEntryTest, MaxAllowedBackoff) {
  184. for (int i = 0; i < 30; ++i) {
  185. entry_->UpdateWithResponse(503);
  186. }
  187. base::TimeDelta delay = entry_->GetExponentialBackoffReleaseTime() - now_;
  188. EXPECT_EQ(delay.InMilliseconds(),
  189. MockExtensionThrottleEntry::kDefaultMaximumBackoffMs);
  190. }
  191. TEST_F(ExtensionThrottleEntryTest, MalformedContent) {
  192. for (int i = 0; i < 5; ++i)
  193. entry_->UpdateWithResponse(503);
  194. TimeTicks release_after_failures = entry_->GetExponentialBackoffReleaseTime();
  195. // Inform the entry that a response body was malformed, which is supposed to
  196. // increase the back-off time. Note that we also submit a successful
  197. // UpdateWithResponse to pair with ReceivedContentWasMalformed() since that
  198. // is what happens in practice (if a body is received, then a non-500
  199. // response must also have been received).
  200. entry_->ReceivedContentWasMalformed(200);
  201. entry_->UpdateWithResponse(200);
  202. EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), release_after_failures);
  203. }
  204. TEST_F(ExtensionThrottleEntryTest, SlidingWindow) {
  205. int max_send = ExtensionThrottleEntry::kDefaultMaxSendThreshold;
  206. int sliding_window = ExtensionThrottleEntry::kDefaultSlidingWindowPeriodMs;
  207. TimeTicks time_1 =
  208. entry_->ImplGetTimeNow() + base::Milliseconds(sliding_window / 3);
  209. TimeTicks time_2 =
  210. entry_->ImplGetTimeNow() + base::Milliseconds(2 * sliding_window / 3);
  211. TimeTicks time_3 =
  212. entry_->ImplGetTimeNow() + base::Milliseconds(sliding_window);
  213. TimeTicks time_4 =
  214. entry_->ImplGetTimeNow() +
  215. base::Milliseconds(sliding_window + 2 * sliding_window / 3);
  216. entry_->set_exponential_backoff_release_time(time_1);
  217. for (int i = 0; i < max_send / 2; ++i) {
  218. EXPECT_EQ(2 * sliding_window / 3,
  219. entry_->ReserveSendingTimeForNextRequest(time_2));
  220. }
  221. EXPECT_EQ(time_2, entry_->sliding_window_release_time());
  222. entry_->set_fake_now(time_3);
  223. for (int i = 0; i < (max_send + 1) / 2; ++i)
  224. EXPECT_EQ(0, entry_->ReserveSendingTimeForNextRequest(TimeTicks()));
  225. EXPECT_EQ(time_4, entry_->sliding_window_release_time());
  226. }
  227. TEST(ExtensionThrottleManagerTest, IsUrlStandardised) {
  228. MockExtensionThrottleManager manager;
  229. GurlAndString test_values[] = {
  230. GurlAndString(GURL("http://www.example.com"),
  231. std::string("http://www.example.com/"), __LINE__),
  232. GurlAndString(GURL("http://www.Example.com"),
  233. std::string("http://www.example.com/"), __LINE__),
  234. GurlAndString(GURL("http://www.ex4mple.com/Pr4c71c41"),
  235. std::string("http://www.ex4mple.com/pr4c71c41"), __LINE__),
  236. GurlAndString(GURL("http://www.example.com/0/token/false"),
  237. std::string("http://www.example.com/0/token/false"),
  238. __LINE__),
  239. GurlAndString(GURL("http://www.example.com/index.php?code=javascript"),
  240. std::string("http://www.example.com/index.php"), __LINE__),
  241. GurlAndString(GURL("http://www.example.com/index.php?code=1#superEntry"),
  242. std::string("http://www.example.com/index.php"), __LINE__),
  243. GurlAndString(GURL("http://www.example.com/index.php#superEntry"),
  244. std::string("http://www.example.com/index.php"), __LINE__),
  245. GurlAndString(GURL("http://www.example.com:1234/"),
  246. std::string("http://www.example.com:1234/"), __LINE__)};
  247. for (unsigned int i = 0; i < std::size(test_values); ++i) {
  248. std::string temp = manager.GetIdFromUrl(test_values[i].url);
  249. EXPECT_EQ(temp, test_values[i].result)
  250. << "Test case #" << i << " line " << test_values[i].line << " failed";
  251. }
  252. }
  253. TEST(ExtensionThrottleManagerTest, AreEntriesBeingCollected) {
  254. MockExtensionThrottleManager manager;
  255. manager.CreateEntry(true); // true = Entry is outdated.
  256. manager.CreateEntry(true);
  257. manager.CreateEntry(true);
  258. manager.GarbageCollectEntries();
  259. EXPECT_EQ(0, manager.GetNumberOfEntries());
  260. manager.CreateEntry(false);
  261. manager.CreateEntry(false);
  262. manager.CreateEntry(false);
  263. manager.CreateEntry(true);
  264. manager.GarbageCollectEntries();
  265. EXPECT_EQ(3, manager.GetNumberOfEntries());
  266. }
  267. TEST(ExtensionThrottleManagerTest, IsHostBeingRegistered) {
  268. MockExtensionThrottleManager manager;
  269. manager.RegisterRequestUrl(GURL("http://www.example.com/"));
  270. manager.RegisterRequestUrl(GURL("http://www.google.com/"));
  271. manager.RegisterRequestUrl(GURL("http://www.google.com/index/0"));
  272. manager.RegisterRequestUrl(GURL("http://www.google.com/index/0?code=1"));
  273. manager.RegisterRequestUrl(GURL("http://www.google.com/index/0#lolsaure"));
  274. EXPECT_EQ(3, manager.GetNumberOfEntries());
  275. }
  276. TEST(ExtensionThrottleManagerTest, LocalHostOptedOut) {
  277. MockExtensionThrottleManager manager;
  278. // A localhost entry should always be opted out.
  279. ExtensionThrottleEntry* localhost_entry =
  280. manager.RegisterRequestUrl(GURL("http://localhost/hello"));
  281. EXPECT_FALSE(localhost_entry->ShouldRejectRequest());
  282. for (int i = 0; i < 10; ++i) {
  283. localhost_entry->UpdateWithResponse(503);
  284. }
  285. EXPECT_FALSE(localhost_entry->ShouldRejectRequest());
  286. // We're not mocking out GetTimeNow() in this scenario
  287. // so add a 100 ms buffer to avoid flakiness (that should always
  288. // give enough time to get from the TimeTicks::Now() call here
  289. // to the TimeTicks::Now() call in the entry class).
  290. EXPECT_GT(TimeTicks::Now() + base::Milliseconds(100),
  291. localhost_entry->GetExponentialBackoffReleaseTime());
  292. }
  293. TEST(ExtensionThrottleManagerTest, ClearOnNetworkChange) {
  294. for (int i = 0; i < 2; ++i) {
  295. MockExtensionThrottleManager manager;
  296. ExtensionThrottleEntry* entry_before =
  297. manager.RegisterRequestUrl(GURL("http://www.example.com/"));
  298. for (int j = 0; j < 10; ++j) {
  299. entry_before->UpdateWithResponse(503);
  300. }
  301. EXPECT_TRUE(entry_before->ShouldRejectRequest());
  302. switch (i) {
  303. case 0:
  304. manager.SetOnline(/*is_online=*/true);
  305. break;
  306. case 1:
  307. manager.SetOnline(/*is_online=*/false);
  308. break;
  309. default:
  310. FAIL();
  311. }
  312. ExtensionThrottleEntry* entry_after =
  313. manager.RegisterRequestUrl(GURL("http://www.example.com/"));
  314. EXPECT_FALSE(entry_after->ShouldRejectRequest());
  315. }
  316. }
  317. TEST(ExtensionThrottleManagerTest, UseAfterNetworkChange) {
  318. MockExtensionThrottleManager manager;
  319. const GURL test_url("http://www.example.com/");
  320. EXPECT_FALSE(manager.ShouldRejectRequest(test_url));
  321. manager.SetOnline(/*is_online=*/false);
  322. manager.SetOnline(/*is_online=*/true);
  323. net::RedirectInfo redirect_info;
  324. redirect_info.new_url = GURL("http://www.newsite.com");
  325. EXPECT_FALSE(manager.ShouldRejectRedirect(test_url, redirect_info));
  326. manager.SetOnline(/*is_online=*/false);
  327. manager.SetOnline(/*is_online=*/true);
  328. auto response_head = network::mojom::URLResponseHead::New();
  329. manager.WillProcessResponse(redirect_info.new_url, *response_head);
  330. }
  331. } // namespace extensions