blob: be682690db367ad393a2df4e44cfec25ffcbabce [file] [log] [blame]
Googler11871152020-10-01 14:59:09 -04001// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
2// reserved. Use of this source code is governed by a BSD-style license that
3// can be found in the LICENSE file.
4
Googler39a97572023-12-13 22:53:26 +00005#include <memory>
Googler11871152020-10-01 14:59:09 -04006#include <vector>
7
Googler39a97572023-12-13 22:53:26 +00008#include "include/base/cef_callback.h"
9#include "include/base/cef_lock.h"
Googler11871152020-10-01 14:59:09 -040010#include "include/cef_file_util.h"
11#include "include/cef_waitable_event.h"
12#include "include/wrapper/cef_closure_task.h"
13#include "include/wrapper/cef_resource_manager.h"
14#include "include/wrapper/cef_scoped_temp_dir.h"
15#include "include/wrapper/cef_stream_resource_handler.h"
16#include "tests/ceftests/routing_test_handler.h"
Googler39a97572023-12-13 22:53:26 +000017#include "tests/ceftests/test_util.h"
Googler11871152020-10-01 14:59:09 -040018#include "tests/gtest/include/gtest/gtest.h"
19#include "tests/shared/browser/file_util.h"
20
21namespace {
22
23std::string CreateMessage(const std::string& name, const std::string& value) {
24 return name + ":" + value;
25}
26
27// The returned contents execute a JavaScript callback containing |message|.
28std::string CreateContents(const std::string& message) {
29 return "<html><body>" + message +
30 "<script>"
31 "window.testQuery({request:'" +
32 message +
33 "'});"
34 "</script></html></body>";
35}
36
37void WriteFile(const std::string& path, const std::string& contents) {
38 int contents_size = static_cast<int>(contents.size());
39 int write_ct =
40 client::file_util::WriteFile(path, contents.data(), contents_size);
41 EXPECT_EQ(contents_size, write_ct);
42}
43
44CefRefPtr<CefResourceHandler> CreateContentsResourceHandler(
45 const std::string& message) {
46 const std::string& contents = CreateContents(message);
47 CefRefPtr<CefStreamReader> stream = CefStreamReader::CreateForData(
48 static_cast<void*>(const_cast<char*>(contents.data())),
49 contents.length());
50 return new CefStreamResourceHandler("text/html", stream);
51}
52
53const char kDoneMsg[] = "ResourceManagerTestHandler.Done";
54const char kNotHandled[] = "NotHandled";
55
56// Browser side.
57class ResourceManagerTestHandler : public RoutingTestHandler {
58 public:
59 struct State {
60 State() : manager_(new CefResourceManager()), expected_message_ct_(0) {}
61
62 CefRefPtr<CefResourceManager> manager_;
63
64 // Set of URLs that will be loaded.
65 std::vector<std::string> urls_;
66
67 // Set of messages that were received.
68 std::vector<std::string> messages_;
69
70 // If non-zero the test will not complete until the expected number of
71 // messages have been received.
72 size_t expected_message_ct_;
73 };
74
75 explicit ResourceManagerTestHandler(State* state)
76 : state_(state), current_url_(0) {
77 EXPECT_TRUE(state_);
78 EXPECT_TRUE(state_->manager_.get());
79 EXPECT_TRUE(!state_->urls_.empty());
80 EXPECT_TRUE(state_->messages_.empty());
81 }
82
83 void RunTest() override {
84 // Create the browser.
85 CreateBrowser(GetNextURL());
86
Googler39a97572023-12-13 22:53:26 +000087 SetTestTimeout(5000);
Googler11871152020-10-01 14:59:09 -040088 }
89
90 cef_return_value_t OnBeforeResourceLoad(
91 CefRefPtr<CefBrowser> browser,
92 CefRefPtr<CefFrame> frame,
93 CefRefPtr<CefRequest> request,
Googler39a97572023-12-13 22:53:26 +000094 CefRefPtr<CefCallback> callback) override {
95 if (IsChromeRuntimeEnabled() && request->GetResourceType() == RT_FAVICON) {
96 // Ignore favicon requests.
97 return RV_CANCEL;
98 }
99
Googler11871152020-10-01 14:59:09 -0400100 return state_->manager_->OnBeforeResourceLoad(browser, frame, request,
101 callback);
102 }
103
104 CefRefPtr<CefResourceHandler> GetResourceHandler(
105 CefRefPtr<CefBrowser> browser,
106 CefRefPtr<CefFrame> frame,
107 CefRefPtr<CefRequest> request) override {
108 // The ProviderDoNothing test destroys the manager before the handler.
109 if (state_->manager_) {
110 CefRefPtr<CefResourceHandler> handler =
111 state_->manager_->GetResourceHandler(browser, frame, request);
Googler39a97572023-12-13 22:53:26 +0000112 if (handler.get()) {
Googler11871152020-10-01 14:59:09 -0400113 return handler;
Googler39a97572023-12-13 22:53:26 +0000114 }
Googler11871152020-10-01 14:59:09 -0400115 }
116
117 return CreateContentsResourceHandler(CreateMessage(kDoneMsg, kNotHandled));
118 }
119
120 bool OnQuery(CefRefPtr<CefBrowser> browser,
121 CefRefPtr<CefFrame> frame,
Googler39a97572023-12-13 22:53:26 +0000122 int64_t query_id,
Googler11871152020-10-01 14:59:09 -0400123 const CefString& request,
124 bool persistent,
125 CefRefPtr<Callback> callback) override {
126 state_->messages_.push_back(request);
127 callback->Success("");
128
Googler39a97572023-12-13 22:53:26 +0000129 CefPostTask(TID_UI, base::BindOnce(&ResourceManagerTestHandler::Continue,
130 this, browser));
Googler11871152020-10-01 14:59:09 -0400131
132 return true;
133 }
134
135 // Wait a bit before destroying the test. Used with ProviderDoNothing.
136 void DelayedDestroyTest() {
137 CefPostDelayedTask(
Googler39a97572023-12-13 22:53:26 +0000138 TID_UI, base::BindOnce(&ResourceManagerTestHandler::DestroyTest, this),
Googler11871152020-10-01 14:59:09 -0400139 100);
140 }
141
142 private:
143 void Continue(CefRefPtr<CefBrowser> browser) {
144 if (state_->expected_message_ct_ == 0) {
145 // Load each URL sequentially.
146 const std::string& next_url = GetNextURL();
Googler39a97572023-12-13 22:53:26 +0000147 if (next_url.empty()) {
Googler11871152020-10-01 14:59:09 -0400148 DestroyTest();
Googler39a97572023-12-13 22:53:26 +0000149 } else {
Googler11871152020-10-01 14:59:09 -0400150 browser->GetMainFrame()->LoadURL(next_url);
Googler39a97572023-12-13 22:53:26 +0000151 }
Googler11871152020-10-01 14:59:09 -0400152 } else if (state_->messages_.size() == state_->expected_message_ct_) {
153 DestroyTest();
154 }
155 }
156
157 std::string GetNextURL() {
Googler39a97572023-12-13 22:53:26 +0000158 if (current_url_ >= state_->urls_.size()) {
Googler11871152020-10-01 14:59:09 -0400159 return std::string();
Googler39a97572023-12-13 22:53:26 +0000160 }
Googler11871152020-10-01 14:59:09 -0400161 return state_->urls_[current_url_++];
162 }
163
164 State* state_;
165 size_t current_url_;
166
167 IMPLEMENT_REFCOUNTING(ResourceManagerTestHandler);
168};
169
170} // namespace
171
172// Test with no providers.
173TEST(ResourceManagerTest, NoProviders) {
Googler39a97572023-12-13 22:53:26 +0000174 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400175
176 ResourceManagerTestHandler::State state;
177 state.urls_.push_back(kUrl);
178
179 CefRefPtr<ResourceManagerTestHandler> handler =
180 new ResourceManagerTestHandler(&state);
181 handler->ExecuteTest();
182
183 ReleaseAndWaitForDestructor(handler);
184
185 state.manager_ = nullptr;
186
187 // Should get the message returned from GetResourceHandler when the request is
188 // not handled.
189 EXPECT_EQ(state.messages_.size(), 1U);
190 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
191}
192
193namespace {
194
195// Content provider that tracks execution state.
196class TestProvider : public CefResourceManager::Provider {
197 public:
198 struct State {
199 TrackCallback got_on_request_;
200 TrackCallback got_on_request_canceled_;
201 TrackCallback got_destruct_;
Googler39a97572023-12-13 22:53:26 +0000202 base::OnceClosure destruct_callback_;
Googler11871152020-10-01 14:59:09 -0400203 std::string request_url_;
204 };
205
206 explicit TestProvider(State* state) : state_(state) { EXPECT_TRUE(state_); }
207
208 ~TestProvider() {
209 CEF_REQUIRE_IO_THREAD();
210 state_->got_destruct_.yes();
Googler39a97572023-12-13 22:53:26 +0000211 if (!state_->destruct_callback_.is_null()) {
212 std::move(state_->destruct_callback_).Run();
213 }
Googler11871152020-10-01 14:59:09 -0400214 }
215
216 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
217 CEF_REQUIRE_IO_THREAD();
218 EXPECT_FALSE(state_->got_on_request_);
219 EXPECT_FALSE(state_->got_on_request_canceled_);
220
221 state_->got_on_request_.yes();
222 state_->request_url_ = request->url();
223
224 return false;
225 }
226
227 void OnRequestCanceled(
228 scoped_refptr<CefResourceManager::Request> request) override {
229 CEF_REQUIRE_IO_THREAD();
230 EXPECT_TRUE(state_->got_on_request_);
231 EXPECT_FALSE(state_->got_on_request_canceled_);
232
233 state_->got_on_request_canceled_.yes();
234 EXPECT_STREQ(state_->request_url_.c_str(), request->url().c_str());
235 }
236
237 private:
238 State* state_;
239
240 DISALLOW_COPY_AND_ASSIGN(TestProvider);
241};
242
243// Helper that blocks on destruction of 1 or more TestProviders.
244class ProviderDestructHelper {
245 public:
Googler39a97572023-12-13 22:53:26 +0000246 explicit ProviderDestructHelper(int expected_count)
247 : expected_count_(expected_count),
248 event_(CefWaitableEvent::CreateWaitableEvent(true, false)) {
249 CHECK_GT(expected_count_, 0);
Googler11871152020-10-01 14:59:09 -0400250 }
251
Googler39a97572023-12-13 22:53:26 +0000252 base::OnceClosure callback() {
253 return base::BindOnce(
254 [](ProviderDestructHelper* self) { self->DestructCallback(); },
255 base::Unretained(this));
256 }
Googler11871152020-10-01 14:59:09 -0400257
258 void Wait() { event_->Wait(); }
259
260 private:
Googler39a97572023-12-13 22:53:26 +0000261 void DestructCallback() {
262 bool signal = false;
263
264 {
265 base::AutoLock lock_scope(lock_);
266 CHECK_LT(current_count_, expected_count_);
267 if (++current_count_ == expected_count_) {
268 signal = true;
269 }
270 }
271
272 if (signal) {
273 // Don't access any members after calling Signal(), which causes |this| to
274 // be deleted on a different thread.
275 auto event = event_;
Googler11871152020-10-01 14:59:09 -0400276 event->Signal();
Googler39a97572023-12-13 22:53:26 +0000277 }
Googler11871152020-10-01 14:59:09 -0400278 }
279
Googler39a97572023-12-13 22:53:26 +0000280 const int expected_count_;
281 int current_count_ = 0;
Googler11871152020-10-01 14:59:09 -0400282 CefRefPtr<CefWaitableEvent> event_;
Googler39a97572023-12-13 22:53:26 +0000283 base::Lock lock_;
Googler11871152020-10-01 14:59:09 -0400284};
285
286// Test that that the URL retrieved via Request::url() is parsed as expected.
287// Fragment or query components in any order should be removed.
288void TestUrlParsing(const char* kUrl) {
Googler39a97572023-12-13 22:53:26 +0000289 const char kRequestUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400290
291 ResourceManagerTestHandler::State state;
292 state.urls_.push_back(kUrl);
293
294 TestProvider::State provider_state;
295
296 ProviderDestructHelper destruct_helper(1);
297 provider_state.destruct_callback_ = destruct_helper.callback();
298
299 state.manager_->AddProvider(new TestProvider(&provider_state), 0,
300 std::string());
301
302 CefRefPtr<ResourceManagerTestHandler> handler =
303 new ResourceManagerTestHandler(&state);
304 handler->ExecuteTest();
305
306 ReleaseAndWaitForDestructor(handler);
307
308 state.manager_ = nullptr;
309
310 // Wait for the manager to be deleted.
311 destruct_helper.Wait();
312
313 // The provider is called.
314 EXPECT_TRUE(provider_state.got_on_request_);
315 EXPECT_FALSE(provider_state.got_on_request_canceled_);
316 EXPECT_TRUE(provider_state.got_destruct_);
317
318 // The expected URL is received.
319 EXPECT_STREQ(kRequestUrl, provider_state.request_url_.c_str());
320
321 // The request is not handled.
322 EXPECT_EQ(state.messages_.size(), 1U);
323 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
324}
325
326} // namespace
327
328TEST(ResourceManagerTest, UrlParsingNoQueryOrFragment) {
Googler39a97572023-12-13 22:53:26 +0000329 TestUrlParsing("https://test.com/ResourceManagerTest");
Googler11871152020-10-01 14:59:09 -0400330}
331
332TEST(ResourceManagerTest, UrlParsingWithQuery) {
Googler39a97572023-12-13 22:53:26 +0000333 TestUrlParsing("https://test.com/ResourceManagerTest?foo=bar&choo=too");
Googler11871152020-10-01 14:59:09 -0400334}
335
336TEST(ResourceManagerTest, UrlParsingWithFragment) {
Googler39a97572023-12-13 22:53:26 +0000337 TestUrlParsing("https://test.com/ResourceManagerTest#some/fragment");
Googler11871152020-10-01 14:59:09 -0400338}
339
340TEST(ResourceManagerTest, UrlParsingWithQueryAndFragment) {
Googler39a97572023-12-13 22:53:26 +0000341 TestUrlParsing("https://test.com/ResourceManagerTest?foo=bar#some/fragment");
Googler11871152020-10-01 14:59:09 -0400342}
343
344TEST(ResourceManagerTest, UrlParsingWithFragmentAndQuery) {
Googler39a97572023-12-13 22:53:26 +0000345 TestUrlParsing("https://test.com/ResourceManagerTest#some/fragment?foo=bar");
Googler11871152020-10-01 14:59:09 -0400346}
347
348namespace {
349
350const char kProviderId[] = "provider";
351
352// Content provider that performs simple tests.
353class SimpleTestProvider : public TestProvider {
354 public:
355 enum Mode {
356 NOT_HANDLED,
357 CONTINUE,
358 STOP,
359 REMOVE,
360 REMOVE_ALL,
361 DO_NOTHING,
362 };
363
364 SimpleTestProvider(State* state, Mode mode, CefResourceManager* manager)
365 : TestProvider(state), mode_(mode), manager_(manager) {}
366
367 SimpleTestProvider(State* state,
368 Mode mode,
369 CefResourceManager* manager,
Googler39a97572023-12-13 22:53:26 +0000370 base::OnceClosure do_nothing_callback)
Googler11871152020-10-01 14:59:09 -0400371 : TestProvider(state),
372 mode_(mode),
373 manager_(manager),
Googler39a97572023-12-13 22:53:26 +0000374 do_nothing_callback_(std::move(do_nothing_callback)) {}
Googler11871152020-10-01 14:59:09 -0400375
376 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
377 TestProvider::OnRequest(request);
378
Googler39a97572023-12-13 22:53:26 +0000379 if (mode_ == NOT_HANDLED) {
Googler11871152020-10-01 14:59:09 -0400380 return false;
Googler39a97572023-12-13 22:53:26 +0000381 } else if (mode_ == CONTINUE) {
Googler11871152020-10-01 14:59:09 -0400382 request->Continue(nullptr);
Googler39a97572023-12-13 22:53:26 +0000383 } else if (mode_ == STOP) {
Googler11871152020-10-01 14:59:09 -0400384 request->Stop();
Googler39a97572023-12-13 22:53:26 +0000385 } else if (mode_ == REMOVE) {
Googler11871152020-10-01 14:59:09 -0400386 manager_->RemoveProviders(kProviderId);
Googler39a97572023-12-13 22:53:26 +0000387 } else if (mode_ == REMOVE_ALL) {
Googler11871152020-10-01 14:59:09 -0400388 manager_->RemoveAllProviders();
Googler39a97572023-12-13 22:53:26 +0000389 } else if (mode_ == DO_NOTHING) {
Googler11871152020-10-01 14:59:09 -0400390 EXPECT_FALSE(do_nothing_callback_.is_null());
Googler39a97572023-12-13 22:53:26 +0000391 std::move(do_nothing_callback_).Run();
Googler11871152020-10-01 14:59:09 -0400392 }
393
394 return true;
395 }
396
397 private:
398 Mode mode_;
399 CefResourceManager* manager_; // Weak reference.
Googler39a97572023-12-13 22:53:26 +0000400 base::OnceClosure do_nothing_callback_;
Googler11871152020-10-01 14:59:09 -0400401
402 DISALLOW_COPY_AND_ASSIGN(SimpleTestProvider);
403};
404
405} // namespace
406
407// Test with multiple providers that do not handle the request.
408TEST(ResourceManagerTest, ProviderNotHandled) {
Googler39a97572023-12-13 22:53:26 +0000409 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400410
411 ResourceManagerTestHandler::State state;
412 state.urls_.push_back(kUrl);
413
414 TestProvider::State provider_state1;
415 TestProvider::State provider_state2;
416
417 ProviderDestructHelper destruct_helper(2);
418 provider_state1.destruct_callback_ = destruct_helper.callback();
419 provider_state2.destruct_callback_ = destruct_helper.callback();
420
421 state.manager_->AddProvider(
422 new SimpleTestProvider(&provider_state1, SimpleTestProvider::NOT_HANDLED,
423 nullptr),
424 0, std::string());
425 state.manager_->AddProvider(
426 new SimpleTestProvider(&provider_state2, SimpleTestProvider::NOT_HANDLED,
427 nullptr),
428 0, std::string());
429
430 CefRefPtr<ResourceManagerTestHandler> handler =
431 new ResourceManagerTestHandler(&state);
432 handler->ExecuteTest();
433
434 ReleaseAndWaitForDestructor(handler);
435
436 state.manager_ = nullptr;
437
438 // Wait for the manager to be deleted.
439 destruct_helper.Wait();
440
441 // All providers are called.
442 EXPECT_TRUE(provider_state1.got_on_request_);
443 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
444 EXPECT_TRUE(provider_state1.got_destruct_);
445
446 EXPECT_TRUE(provider_state2.got_on_request_);
447 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
448 EXPECT_TRUE(provider_state2.got_destruct_);
449
450 EXPECT_EQ(state.messages_.size(), 1U);
451 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
452}
453
454// Test with multiple providers that all continue.
455TEST(ResourceManagerTest, ProviderContinue) {
Googler39a97572023-12-13 22:53:26 +0000456 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400457
458 ResourceManagerTestHandler::State state;
459 state.urls_.push_back(kUrl);
460
461 TestProvider::State provider_state1;
462 TestProvider::State provider_state2;
463
464 ProviderDestructHelper destruct_helper(2);
465 provider_state1.destruct_callback_ = destruct_helper.callback();
466 provider_state2.destruct_callback_ = destruct_helper.callback();
467
468 state.manager_->AddProvider(
469 new SimpleTestProvider(&provider_state1, SimpleTestProvider::CONTINUE,
470 nullptr),
471 0, std::string());
472 state.manager_->AddProvider(
473 new SimpleTestProvider(&provider_state2, SimpleTestProvider::CONTINUE,
474 nullptr),
475 0, std::string());
476
477 CefRefPtr<ResourceManagerTestHandler> handler =
478 new ResourceManagerTestHandler(&state);
479 handler->ExecuteTest();
480
481 ReleaseAndWaitForDestructor(handler);
482
483 state.manager_ = nullptr;
484
485 // Wait for the manager to be deleted.
486 destruct_helper.Wait();
487
488 // All providers are called.
489 EXPECT_TRUE(provider_state1.got_on_request_);
490 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
491 EXPECT_TRUE(provider_state1.got_destruct_);
492
493 EXPECT_TRUE(provider_state2.got_on_request_);
494 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
495 EXPECT_TRUE(provider_state2.got_destruct_);
496
497 EXPECT_EQ(state.messages_.size(), 1U);
498 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
499}
500
501// Test with multiple providers where the first one stops.
502TEST(ResourceManagerTest, ProviderStop) {
Googler39a97572023-12-13 22:53:26 +0000503 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400504
505 ResourceManagerTestHandler::State state;
506 state.urls_.push_back(kUrl);
507
508 TestProvider::State provider_state1;
509 TestProvider::State provider_state2;
510
511 ProviderDestructHelper destruct_helper(2);
512 provider_state1.destruct_callback_ = destruct_helper.callback();
513 provider_state2.destruct_callback_ = destruct_helper.callback();
514
515 state.manager_->AddProvider(
516 new SimpleTestProvider(&provider_state1, SimpleTestProvider::STOP,
517 nullptr),
518 0, std::string());
519 state.manager_->AddProvider(
520 new SimpleTestProvider(&provider_state2, SimpleTestProvider::CONTINUE,
521 nullptr),
522 0, std::string());
523
524 CefRefPtr<ResourceManagerTestHandler> handler =
525 new ResourceManagerTestHandler(&state);
526 handler->ExecuteTest();
527
528 ReleaseAndWaitForDestructor(handler);
529
530 state.manager_ = nullptr;
531
532 // Wait for the manager to be deleted.
533 destruct_helper.Wait();
534
535 // 1st provider is called.
536 EXPECT_TRUE(provider_state1.got_on_request_);
537 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
538 EXPECT_TRUE(provider_state1.got_destruct_);
539
540 // 2nd provider is not called because the 1st provider stopped.
541 EXPECT_FALSE(provider_state2.got_on_request_);
542 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
543 EXPECT_TRUE(provider_state2.got_destruct_);
544
545 EXPECT_EQ(state.messages_.size(), 1U);
546 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
547}
548
549// Test with multiple providers where the first one removes multiple providers
550// including itself.
551TEST(ResourceManagerTest, ProviderRemove) {
Googler39a97572023-12-13 22:53:26 +0000552 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400553
554 ResourceManagerTestHandler::State state;
555 state.urls_.push_back(kUrl);
556
557 TestProvider::State provider_state1;
558 TestProvider::State provider_state2;
559 TestProvider::State provider_state3;
560
561 ProviderDestructHelper destruct_helper(3);
562 provider_state1.destruct_callback_ = destruct_helper.callback();
563 provider_state2.destruct_callback_ = destruct_helper.callback();
564 provider_state3.destruct_callback_ = destruct_helper.callback();
565
566 state.manager_->AddProvider(
567 new SimpleTestProvider(&provider_state1, SimpleTestProvider::REMOVE,
568 state.manager_.get()),
569 0, kProviderId);
570 state.manager_->AddProvider(
571 new SimpleTestProvider(&provider_state2, SimpleTestProvider::CONTINUE,
572 nullptr),
573 0, kProviderId);
574 state.manager_->AddProvider(
575 new SimpleTestProvider(&provider_state3, SimpleTestProvider::CONTINUE,
576 nullptr),
577 1, std::string());
578
579 CefRefPtr<ResourceManagerTestHandler> handler =
580 new ResourceManagerTestHandler(&state);
581 handler->ExecuteTest();
582
583 ReleaseAndWaitForDestructor(handler);
584
585 state.manager_ = nullptr;
586
587 // Wait for the manager to be deleted.
588 destruct_helper.Wait();
589
590 // 1st provider is called and canceled.
591 EXPECT_TRUE(provider_state1.got_on_request_);
592 EXPECT_TRUE(provider_state1.got_on_request_canceled_);
593 EXPECT_TRUE(provider_state1.got_destruct_);
594
595 // 2nd provider is removed with the 1st provider due to sharing the same
596 // identifier.
597 EXPECT_FALSE(provider_state2.got_on_request_);
598 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
599 EXPECT_TRUE(provider_state2.got_destruct_);
600
601 // 3rd provider is called.
602 EXPECT_TRUE(provider_state3.got_on_request_);
603 EXPECT_FALSE(provider_state3.got_on_request_canceled_);
604 EXPECT_TRUE(provider_state3.got_destruct_);
605
606 EXPECT_EQ(state.messages_.size(), 1U);
607 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
608}
609
610// Test with multiple providers where the first provider removes all.
611TEST(ResourceManagerTest, ProviderRemoveAll) {
Googler39a97572023-12-13 22:53:26 +0000612 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400613
614 ResourceManagerTestHandler::State state;
615 state.urls_.push_back(kUrl);
616
617 TestProvider::State provider_state1;
618 TestProvider::State provider_state2;
619 TestProvider::State provider_state3;
620
621 ProviderDestructHelper destruct_helper(3);
622 provider_state1.destruct_callback_ = destruct_helper.callback();
623 provider_state2.destruct_callback_ = destruct_helper.callback();
624 provider_state3.destruct_callback_ = destruct_helper.callback();
625
626 state.manager_->AddProvider(
627 new SimpleTestProvider(&provider_state1, SimpleTestProvider::REMOVE_ALL,
628 state.manager_.get()),
629 0, std::string());
630 state.manager_->AddProvider(
631 new SimpleTestProvider(&provider_state2, SimpleTestProvider::CONTINUE,
632 nullptr),
633 0, std::string());
634 state.manager_->AddProvider(
635 new SimpleTestProvider(&provider_state3, SimpleTestProvider::CONTINUE,
636 nullptr),
637 1, std::string());
638
639 CefRefPtr<ResourceManagerTestHandler> handler =
640 new ResourceManagerTestHandler(&state);
641 handler->ExecuteTest();
642
643 ReleaseAndWaitForDestructor(handler);
644
645 state.manager_ = nullptr;
646
647 // Wait for the manager to be deleted.
648 destruct_helper.Wait();
649
650 // 1st provider is called and canceled.
651 EXPECT_TRUE(provider_state1.got_on_request_);
652 EXPECT_TRUE(provider_state1.got_on_request_canceled_);
653 EXPECT_TRUE(provider_state1.got_destruct_);
654
655 // 2nd and 3rd providers are not called due to removal.
656 EXPECT_FALSE(provider_state2.got_on_request_);
657 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
658 EXPECT_TRUE(provider_state2.got_destruct_);
659
660 EXPECT_FALSE(provider_state3.got_on_request_);
661 EXPECT_FALSE(provider_state3.got_on_request_canceled_);
662 EXPECT_TRUE(provider_state3.got_destruct_);
663
664 EXPECT_EQ(state.messages_.size(), 1U);
665 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
666}
667
668// Test with multiple providers that do not continue and will be destroyed when
669// the manager is destroyed.
670TEST(ResourceManagerTest, ProviderDoNothing) {
Googler39a97572023-12-13 22:53:26 +0000671 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -0400672
673 ResourceManagerTestHandler::State state;
674 state.urls_.push_back(kUrl);
675
676 TestProvider::State provider_state1;
677 TestProvider::State provider_state2;
678
679 ProviderDestructHelper destruct_helper(2);
680 provider_state1.destruct_callback_ = destruct_helper.callback();
681 provider_state2.destruct_callback_ = destruct_helper.callback();
682
683 CefRefPtr<ResourceManagerTestHandler> handler =
684 new ResourceManagerTestHandler(&state);
685
686 // DelayedDestroyTest will be executed from SimpleTestHandler::OnRequest.
687 state.manager_->AddProvider(
688 new SimpleTestProvider(
689 &provider_state1, SimpleTestProvider::DO_NOTHING, nullptr,
Googler39a97572023-12-13 22:53:26 +0000690 base::BindOnce(&ResourceManagerTestHandler::DelayedDestroyTest,
691 handler)),
Googler11871152020-10-01 14:59:09 -0400692 0, std::string());
693 state.manager_->AddProvider(
694 new SimpleTestProvider(&provider_state2, SimpleTestProvider::DO_NOTHING,
695 nullptr),
696 0, std::string());
697
698 handler->ExecuteTest();
699
700 // Destroy the resource manager before the handler so that pending requests
701 // are canceled. ResourceManagerTestHandler::GetResourceHandler will be called
702 // after the manager is destroyed.
703 state.manager_ = nullptr;
704
705 // Wait for the manager to be deleted.
706 destruct_helper.Wait();
707
708 ReleaseAndWaitForDestructor(handler);
709
710 // Only the first provider is called. It will be canceled when the manager is
711 // destroyed.
712 EXPECT_TRUE(provider_state1.got_on_request_);
713 EXPECT_TRUE(provider_state1.got_on_request_canceled_);
714 EXPECT_TRUE(provider_state1.got_destruct_);
715
716 EXPECT_FALSE(provider_state2.got_on_request_);
717 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
718 EXPECT_TRUE(provider_state2.got_destruct_);
719
720 // Nothing completed.
721 EXPECT_EQ(state.messages_.size(), 0U);
722}
723
724// Test AddContentProvider.
725TEST(ResourceManagerTest, ContentProvider) {
Googler39a97572023-12-13 22:53:26 +0000726 const char kUrl1[] = "https://test.com/ResourceManagerTest1";
727 const char kUrl2[] = "https://test.com/ResourceManagerTest2";
728 const char kUrl3[] = "https://test.com/ResourceManagerTest3";
Googler11871152020-10-01 14:59:09 -0400729
730 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
731 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
732 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
733
734 ResourceManagerTestHandler::State state;
735 state.urls_.push_back(kUrl1);
736 state.urls_.push_back(kUrl2);
737 state.urls_.push_back(kUrl3);
738
739 // Only the first 2 URLs will be handled.
740 state.manager_->AddContentProvider(kUrl1, CreateContents(success1_message),
741 "text/html", 0, std::string());
742 state.manager_->AddContentProvider(kUrl2, CreateContents(success2_message),
743 "text/html", 0, std::string());
744
745 CefRefPtr<ResourceManagerTestHandler> handler =
746 new ResourceManagerTestHandler(&state);
747 handler->ExecuteTest();
748
749 ReleaseAndWaitForDestructor(handler);
750
751 state.manager_ = nullptr;
752
753 // Wait for the manager to be deleted.
754 WaitForIOThread();
755
756 // Both providers are called and return the expected results.
757 EXPECT_EQ(state.messages_.size(), 3U);
758 EXPECT_EQ(success1_message, state.messages_[0]);
759 EXPECT_EQ(success2_message, state.messages_[1]);
760 EXPECT_EQ(not_handled_message, state.messages_[2]);
761}
762
763// Test AddDirectoryProvider.
764TEST(ResourceManagerTest, DirectoryProvider) {
Googler39a97572023-12-13 22:53:26 +0000765 const char kUrlBase[] = "https://test.com/ResourceManager";
Googler11871152020-10-01 14:59:09 -0400766 const char kFile1[] = "File1.html";
767 const char kFile2[] = "File2.html";
768 const char kFile3[] = "File3.html";
769 const char kFile4[] = "File4.html";
770
771 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
772 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
773 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
774 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
775
776 ResourceManagerTestHandler::State state;
777 state.urls_.push_back(kUrlBase + std::string("/") + kFile1);
778 state.urls_.push_back(kUrlBase + std::string("/") + kFile2);
779 state.urls_.push_back(kUrlBase + std::string("/sub/") + kFile3);
780 state.urls_.push_back(kUrlBase + std::string("/") + kFile4);
781
782 CefScopedTempDir scoped_dir;
783 EXPECT_TRUE(scoped_dir.CreateUniqueTempDir());
784
785 // Write the files to disk.
786 const std::string& temp_dir = scoped_dir.GetPath();
787 WriteFile(client::file_util::JoinPath(temp_dir, kFile1),
788 CreateContents(success1_message));
789 WriteFile(client::file_util::JoinPath(temp_dir, kFile2),
790 CreateContents(success2_message));
791
792 // Also include a subdirectory.
793 const std::string& sub_dir = client::file_util::JoinPath(temp_dir, "sub");
794 EXPECT_TRUE(CefCreateDirectory(sub_dir));
795 WriteFile(client::file_util::JoinPath(sub_dir, kFile3),
796 CreateContents(success3_message));
797
798 state.manager_->AddDirectoryProvider(kUrlBase, temp_dir, 0, std::string());
799
800 CefRefPtr<ResourceManagerTestHandler> handler =
801 new ResourceManagerTestHandler(&state);
802 handler->ExecuteTest();
803
804 ReleaseAndWaitForDestructor(handler);
805
806 state.manager_ = nullptr;
807
808 // Wait for the manager to be deleted.
809 WaitForIOThread();
810
811 EXPECT_TRUE(scoped_dir.Delete());
812
813 // The first 3 URLs are handled.
814 EXPECT_EQ(state.messages_.size(), 4U);
815 EXPECT_EQ(success1_message, state.messages_[0]);
816 EXPECT_EQ(success2_message, state.messages_[1]);
817 EXPECT_EQ(success3_message, state.messages_[2]);
818 EXPECT_EQ(not_handled_message, state.messages_[3]);
819}
820
821// Test AddArchiveProvider.
822TEST(ResourceManagerTest, ArchiveProvider) {
Googler39a97572023-12-13 22:53:26 +0000823 const char kUrlBase[] = "https://test.com/ResourceManager";
Googler11871152020-10-01 14:59:09 -0400824 const char kFile1[] = "File1.html";
825 const char kFile2[] = "File2.html";
826 const char kFile3[] = "File3.html";
827 const char kFile4[] = "File4.html";
828
829 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
830 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
831 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
832 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
833
834 ResourceManagerTestHandler::State state;
835 state.urls_.push_back(kUrlBase + std::string("/") + kFile1);
836 state.urls_.push_back(kUrlBase + std::string("/") + kFile2);
837 state.urls_.push_back(kUrlBase + std::string("/sub/") + kFile3);
838 state.urls_.push_back(kUrlBase + std::string("/") + kFile4);
839
840 // Only the first 2 URLs will be handled.
841 CefScopedTempDir scoped_dir;
842 EXPECT_TRUE(scoped_dir.CreateUniqueTempDir());
843
844 const std::string& temp_dir = scoped_dir.GetPath();
845
846 // Write the files to disk.
847 const std::string& file_dir = client::file_util::JoinPath(temp_dir, "files");
848 EXPECT_TRUE(CefCreateDirectory(file_dir));
849 WriteFile(client::file_util::JoinPath(file_dir, kFile1),
850 CreateContents(success1_message));
851 WriteFile(client::file_util::JoinPath(file_dir, kFile2),
852 CreateContents(success2_message));
853
854 // Also include a subdirectory.
855 const std::string& sub_dir = client::file_util::JoinPath(file_dir, "sub");
856 EXPECT_TRUE(CefCreateDirectory(sub_dir));
857 WriteFile(client::file_util::JoinPath(sub_dir, kFile3),
858 CreateContents(success3_message));
859
860 const std::string& archive_path =
861 client::file_util::JoinPath(temp_dir, "archive.zip");
862
863 // Create the archive file.
864 EXPECT_TRUE(CefZipDirectory(file_dir, archive_path, false));
865
866 state.manager_->AddArchiveProvider(kUrlBase, archive_path, std::string(), 0,
867 std::string());
868
869 CefRefPtr<ResourceManagerTestHandler> handler =
870 new ResourceManagerTestHandler(&state);
871 handler->ExecuteTest();
872
873 ReleaseAndWaitForDestructor(handler);
874
875 state.manager_ = nullptr;
876
877 // Wait for the manager to be deleted.
878 WaitForIOThread();
879
880 EXPECT_TRUE(scoped_dir.Delete());
881
882 // The first 3 URLs are handled.
883 EXPECT_EQ(state.messages_.size(), 4U);
884 EXPECT_EQ(success1_message, state.messages_[0]);
885 EXPECT_EQ(success2_message, state.messages_[1]);
886 EXPECT_EQ(success3_message, state.messages_[2]);
887 EXPECT_EQ(not_handled_message, state.messages_[3]);
888}
889
890namespace {
891
892// Content provider that only handles a single request.
893class OneShotProvider : public CefResourceManager::Provider {
894 public:
895 OneShotProvider(const std::string& content,
Googler39a97572023-12-13 22:53:26 +0000896 base::OnceClosure destruct_callback)
897 : done_(false),
898 content_(content),
899 destruct_callback_(std::move(destruct_callback)) {
Googler11871152020-10-01 14:59:09 -0400900 EXPECT_FALSE(content.empty());
901 }
902
903 ~OneShotProvider() {
904 CEF_REQUIRE_IO_THREAD();
Googler39a97572023-12-13 22:53:26 +0000905 std::move(destruct_callback_).Run();
Googler11871152020-10-01 14:59:09 -0400906 }
907
908 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
909 CEF_REQUIRE_IO_THREAD();
910
911 if (done_) {
912 // Provider only handles a single request.
913 return false;
914 }
915
916 done_ = true;
917
918 CefRefPtr<CefStreamReader> stream = CefStreamReader::CreateForData(
919 static_cast<void*>(const_cast<char*>(content_.data())),
920 content_.length());
921
922 request->Continue(new CefStreamResourceHandler("text/html", stream));
923 return true;
924 }
925
926 private:
927 bool done_;
928 std::string content_;
Googler39a97572023-12-13 22:53:26 +0000929 base::OnceClosure destruct_callback_;
Googler11871152020-10-01 14:59:09 -0400930
931 DISALLOW_COPY_AND_ASSIGN(OneShotProvider);
932};
933
934} // namespace
935
936// Test that providers are called in the expected order and return expected
937// results.
938TEST(ResourceManagerTest, ProviderOrder) {
Googler39a97572023-12-13 22:53:26 +0000939 const char kUrl1[] = "https://test.com/ResourceManagerTest1";
940 const char kUrl2[] = "https://test.com/ResourceManagerTest2";
941 const char kUrl3[] = "https://test.com/ResourceManagerTest3";
942 const char kUrl4[] = "https://test.com/ResourceManagerTest4";
943 const char kUrl5[] = "https://test.com/ResourceManagerTest5";
Googler11871152020-10-01 14:59:09 -0400944
945 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
946 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
947 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
948 const std::string& success4_message = CreateMessage(kDoneMsg, "Success4");
949 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
950
951 ResourceManagerTestHandler::State state;
952 state.urls_.push_back(kUrl1);
953 state.urls_.push_back(kUrl2);
954 state.urls_.push_back(kUrl3);
955 state.urls_.push_back(kUrl4);
956 state.urls_.push_back(kUrl5);
957
958 ProviderDestructHelper destruct_helper(4);
959
960 // Resulting order should be sequential; success1 .. success4.
961 state.manager_->AddProvider(
962 new OneShotProvider(CreateContents(success2_message),
963 destruct_helper.callback()),
964 0, std::string());
965 state.manager_->AddProvider(
966 new OneShotProvider(CreateContents(success1_message),
967 destruct_helper.callback()),
968 -100, std::string());
969 state.manager_->AddProvider(
970 new OneShotProvider(CreateContents(success4_message),
971 destruct_helper.callback()),
972 100, std::string());
973 state.manager_->AddProvider(
974 new OneShotProvider(CreateContents(success3_message),
975 destruct_helper.callback()),
976 0, std::string());
977
978 CefRefPtr<ResourceManagerTestHandler> handler =
979 new ResourceManagerTestHandler(&state);
980 handler->ExecuteTest();
981
982 ReleaseAndWaitForDestructor(handler);
983
984 state.manager_ = nullptr;
985
986 // Wait for the manager to be deleted.
987 destruct_helper.Wait();
988
989 EXPECT_EQ(state.messages_.size(), 5U);
990 EXPECT_EQ(success1_message, state.messages_[0]);
991 EXPECT_EQ(success2_message, state.messages_[1]);
992 EXPECT_EQ(success3_message, state.messages_[2]);
993 EXPECT_EQ(success4_message, state.messages_[3]);
994 EXPECT_EQ(not_handled_message, state.messages_[4]);
995}
996
997namespace {
998
999// Content provider that returns the path component as the result.
1000class EchoProvider : public CefResourceManager::Provider {
1001 public:
1002 EchoProvider(const std::string& base_url) : base_url_(base_url) {
1003 EXPECT_TRUE(!base_url_.empty());
1004 }
1005
1006 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
1007 CEF_REQUIRE_IO_THREAD();
1008
1009 const std::string& url = request->url();
1010 if (url.find(base_url_) != 0U) {
1011 // Not handled by this provider.
1012 return false;
1013 }
1014
1015 const std::string& content = CreateContents(url);
1016
1017 // Parse the URL to identify the delay.
1018 int delay = atoi(url.substr(base_url_.size()).data());
1019 EXPECT_GE(delay, 0);
1020
1021 CefRefPtr<CefStreamReader> stream = CefStreamReader::CreateForData(
1022 static_cast<void*>(const_cast<char*>(content.data())),
1023 content.length());
1024
Googler39a97572023-12-13 22:53:26 +00001025 CefRefPtr<CefStreamResourceHandler> handler(
1026 new CefStreamResourceHandler("text/html", stream));
1027 CefPostDelayedTask(TID_IO,
1028 base::BindOnce(&CefResourceManager::Request::Continue,
1029 request, handler),
1030 delay);
Googler11871152020-10-01 14:59:09 -04001031
1032 return true;
1033 }
1034
1035 private:
1036 std::string base_url_;
1037
1038 DISALLOW_COPY_AND_ASSIGN(EchoProvider);
1039};
1040
1041} // namespace
1042
1043// Test that many requests pending at the same time complete in the expected
1044// order and return correct results.
1045TEST(ResourceManagerTest, ManyRequests) {
Googler39a97572023-12-13 22:53:26 +00001046 const char kUrl[] = "https://test.com/ResourceManagerTest";
1047 const char kBaseUrl[] = "https://test.com/ResourceManagerSubTest/";
Googler11871152020-10-01 14:59:09 -04001048
1049 ResourceManagerTestHandler::State state;
1050 state.urls_.push_back(kUrl);
1051
1052 state.expected_message_ct_ = 50U;
1053
1054 // Build a page with lots of iframes.
1055 std::stringstream ss;
1056 ss << "<html><body>";
1057 for (size_t i = 0U; i < state.expected_message_ct_; ++i) {
1058 ss << "<iframe src=\"" << kBaseUrl << (i * 10) << "\"></iframe>";
1059 }
1060 ss << "</body></html>";
1061
1062 state.manager_->AddContentProvider(kUrl, ss.str(), "text/html", 0,
1063 std::string());
1064 state.manager_->AddProvider(new EchoProvider(kBaseUrl), 0, std::string());
1065
1066 CefRefPtr<ResourceManagerTestHandler> handler =
1067 new ResourceManagerTestHandler(&state);
1068 handler->ExecuteTest();
1069
1070 ReleaseAndWaitForDestructor(handler);
1071
1072 state.manager_ = nullptr;
1073
1074 // Wait for the manager to be deleted.
1075 WaitForIOThread();
1076
1077 EXPECT_EQ(state.messages_.size(), state.expected_message_ct_);
1078
1079 // Requests should complete in order due to the delay.
1080 for (size_t i = 0; i < state.messages_.size(); ++i) {
1081 ss.str("");
1082 ss << kBaseUrl << (i * 10);
1083 EXPECT_EQ(ss.str(), state.messages_[i]);
1084 }
1085}
1086
1087namespace {
1088
1089// Content provider that only handles a single request and then removes itself
1090// from the manager.
1091class OneShotRemovalProvider : public TestProvider {
1092 public:
1093 OneShotRemovalProvider(State* state,
1094 const std::string& content,
1095 CefResourceManager* manager,
1096 const std::string& identifier,
1097 bool remove_before_continue)
1098 : TestProvider(state),
1099 content_(content),
1100 manager_(manager),
1101 identifier_(identifier),
1102 remove_before_continue_(remove_before_continue) {
1103 EXPECT_FALSE(content.empty());
1104 }
1105
1106 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
1107 TestProvider::OnRequest(request);
1108
1109 CefRefPtr<CefStreamReader> stream = CefStreamReader::CreateForData(
1110 static_cast<void*>(const_cast<char*>(content_.data())),
1111 content_.length());
1112
1113 if (remove_before_continue_) {
1114 // Removing the provider before continuing should trigger a call to
1115 // OnRequestCanceled.
Googler39a97572023-12-13 22:53:26 +00001116 if (identifier_.empty()) {
Googler11871152020-10-01 14:59:09 -04001117 manager_->RemoveAllProviders();
Googler39a97572023-12-13 22:53:26 +00001118 } else {
Googler11871152020-10-01 14:59:09 -04001119 manager_->RemoveProviders(identifier_);
Googler39a97572023-12-13 22:53:26 +00001120 }
Googler11871152020-10-01 14:59:09 -04001121 }
1122
1123 request->Continue(new CefStreamResourceHandler("text/html", stream));
1124
1125 if (!remove_before_continue_) {
1126 // The request has already completed so OnRequestCanceled is not called.
Googler39a97572023-12-13 22:53:26 +00001127 if (identifier_.empty()) {
Googler11871152020-10-01 14:59:09 -04001128 manager_->RemoveAllProviders();
Googler39a97572023-12-13 22:53:26 +00001129 } else {
Googler11871152020-10-01 14:59:09 -04001130 manager_->RemoveProviders(identifier_);
Googler39a97572023-12-13 22:53:26 +00001131 }
Googler11871152020-10-01 14:59:09 -04001132 }
1133
1134 return true;
1135 }
1136
1137 private:
1138 std::string content_;
1139 CefResourceManager* manager_; // Weak reference.
1140 std::string identifier_;
1141 bool remove_before_continue_;
1142
1143 DISALLOW_COPY_AND_ASSIGN(OneShotRemovalProvider);
1144};
1145
1146} // namespace
1147
1148// Test that removal of the current provider after continue has the expected
1149// results.
1150TEST(ResourceManagerTest, RemoveProviderAfterContinue) {
Googler39a97572023-12-13 22:53:26 +00001151 const char kUrl1[] = "https://test.com/ResourceManagerTest1";
1152 const char kUrl2[] = "https://test.com/ResourceManagerTest2";
1153 const char kUrl3[] = "https://test.com/ResourceManagerTest3";
1154 const char kUrl4[] = "https://test.com/ResourceManagerTest4";
Googler11871152020-10-01 14:59:09 -04001155
1156 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
1157 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
1158 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
1159 const std::string& success4_message = CreateMessage(kDoneMsg, "Success4");
1160 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
1161
1162 ResourceManagerTestHandler::State state;
1163 state.urls_.push_back(kUrl1);
1164 state.urls_.push_back(kUrl2);
1165 state.urls_.push_back(kUrl3);
1166 state.urls_.push_back(kUrl4);
1167
1168 TestProvider::State provider_state1;
1169 TestProvider::State provider_state2;
1170 TestProvider::State provider_state3;
1171 TestProvider::State provider_state4;
1172
1173 ProviderDestructHelper destruct_helper(4);
1174 provider_state1.destruct_callback_ = destruct_helper.callback();
1175 provider_state2.destruct_callback_ = destruct_helper.callback();
1176 provider_state3.destruct_callback_ = destruct_helper.callback();
1177 provider_state4.destruct_callback_ = destruct_helper.callback();
1178
1179 const char kIdentifier1[] = "id1";
1180 const char kIdentifier2[] = "id2";
1181 const char kIdentifier4[] = "id4";
1182
1183 // Resulting order should be sequential; success1 .. success4.
1184 state.manager_->AddProvider(
1185 new OneShotRemovalProvider(&provider_state2,
1186 CreateContents(success2_message),
1187 state.manager_.get(), kIdentifier2, false),
1188 0, kIdentifier2);
1189 state.manager_->AddProvider(
1190 new OneShotRemovalProvider(&provider_state1,
1191 CreateContents(success1_message),
1192 state.manager_.get(), kIdentifier1, false),
1193 -100, kIdentifier1);
1194 state.manager_->AddProvider(
1195 new OneShotRemovalProvider(&provider_state4,
1196 CreateContents(success4_message),
1197 state.manager_.get(), kIdentifier4, false),
1198 100, kIdentifier4);
1199 // Will be removed at the same time as #2 and therefore never called.
1200 state.manager_->AddProvider(
1201 new OneShotRemovalProvider(&provider_state3,
1202 CreateContents(success3_message),
1203 state.manager_.get(), kIdentifier2, false),
1204 0, kIdentifier2);
1205
1206 CefRefPtr<ResourceManagerTestHandler> handler =
1207 new ResourceManagerTestHandler(&state);
1208 handler->ExecuteTest();
1209
1210 ReleaseAndWaitForDestructor(handler);
1211
1212 state.manager_ = nullptr;
1213
1214 // Wait for the manager to be deleted.
1215 destruct_helper.Wait();
1216
1217 // All providers except for 3 (which is removed at the same time as 2 and
1218 // therefore never executed) should complete.
1219 EXPECT_EQ(state.messages_.size(), 4U);
1220 EXPECT_EQ(success1_message, state.messages_[0]);
1221 EXPECT_EQ(success2_message, state.messages_[1]);
1222 EXPECT_EQ(success4_message, state.messages_[2]);
1223 EXPECT_EQ(not_handled_message, state.messages_[3]);
1224
1225 EXPECT_TRUE(provider_state1.got_on_request_);
1226 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1227 EXPECT_TRUE(provider_state1.got_destruct_);
1228
1229 EXPECT_TRUE(provider_state2.got_on_request_);
1230 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1231 EXPECT_TRUE(provider_state2.got_destruct_);
1232
1233 // Removed at the same time as 2 and therefore not executed.
1234 EXPECT_FALSE(provider_state3.got_on_request_);
1235 EXPECT_FALSE(provider_state3.got_on_request_canceled_);
1236 EXPECT_TRUE(provider_state3.got_destruct_);
1237
1238 EXPECT_TRUE(provider_state4.got_on_request_);
1239 EXPECT_FALSE(provider_state4.got_on_request_canceled_);
1240 EXPECT_TRUE(provider_state4.got_destruct_);
1241}
1242
1243// Test that removal of the current provider before continue has the expected
1244// results.
1245TEST(ResourceManagerTest, RemoveProviderBeforeContinue) {
Googler39a97572023-12-13 22:53:26 +00001246 const char kUrl1[] = "https://test.com/ResourceManagerTest1";
1247 const char kUrl2[] = "https://test.com/ResourceManagerTest2";
1248 const char kUrl3[] = "https://test.com/ResourceManagerTest3";
1249 const char kUrl4[] = "https://test.com/ResourceManagerTest4";
Googler11871152020-10-01 14:59:09 -04001250
1251 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
1252 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
1253 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
1254 const std::string& success4_message = CreateMessage(kDoneMsg, "Success4");
1255 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
1256
1257 ResourceManagerTestHandler::State state;
1258 state.urls_.push_back(kUrl1);
1259 state.urls_.push_back(kUrl2);
1260 state.urls_.push_back(kUrl3);
1261 state.urls_.push_back(kUrl4);
1262
1263 TestProvider::State provider_state1;
1264 TestProvider::State provider_state2;
1265 TestProvider::State provider_state3;
1266 TestProvider::State provider_state4;
1267
1268 ProviderDestructHelper destruct_helper(4);
1269 provider_state1.destruct_callback_ = destruct_helper.callback();
1270 provider_state2.destruct_callback_ = destruct_helper.callback();
1271 provider_state3.destruct_callback_ = destruct_helper.callback();
1272 provider_state4.destruct_callback_ = destruct_helper.callback();
1273
1274 const char kIdentifier1[] = "id1";
1275 const char kIdentifier2[] = "id2";
1276 const char kIdentifier4[] = "id4";
1277
1278 // Resulting order should be sequential; success1 .. success4.
1279 state.manager_->AddProvider(
1280 new OneShotRemovalProvider(&provider_state2,
1281 CreateContents(success2_message),
1282 state.manager_.get(), kIdentifier2, true),
1283 0, kIdentifier2);
1284 state.manager_->AddProvider(
1285 new OneShotRemovalProvider(&provider_state1,
1286 CreateContents(success1_message),
1287 state.manager_.get(), kIdentifier1, true),
1288 -100, kIdentifier1);
1289 state.manager_->AddProvider(
1290 new OneShotRemovalProvider(&provider_state4,
1291 CreateContents(success4_message),
1292 state.manager_.get(), kIdentifier4, true),
1293 100, kIdentifier4);
1294 state.manager_->AddProvider(
1295 new OneShotRemovalProvider(&provider_state3,
1296 CreateContents(success3_message),
1297 state.manager_.get(), kIdentifier2, true),
1298 0, kIdentifier2);
1299
1300 CefRefPtr<ResourceManagerTestHandler> handler =
1301 new ResourceManagerTestHandler(&state);
1302 handler->ExecuteTest();
1303
1304 ReleaseAndWaitForDestructor(handler);
1305
1306 state.manager_ = nullptr;
1307
1308 // Wait for the manager to be deleted.
1309 destruct_helper.Wait();
1310
1311 // No providers should complete.
1312 EXPECT_EQ(state.messages_.size(), 4U);
1313 EXPECT_EQ(not_handled_message, state.messages_[0]);
1314 EXPECT_EQ(not_handled_message, state.messages_[1]);
1315 EXPECT_EQ(not_handled_message, state.messages_[2]);
1316 EXPECT_EQ(not_handled_message, state.messages_[3]);
1317
1318 // All providers except 3 should be called and then canceled.
1319 EXPECT_TRUE(provider_state1.got_on_request_);
1320 EXPECT_TRUE(provider_state1.got_on_request_canceled_);
1321 EXPECT_TRUE(provider_state1.got_destruct_);
1322
1323 EXPECT_TRUE(provider_state2.got_on_request_);
1324 EXPECT_TRUE(provider_state2.got_on_request_canceled_);
1325 EXPECT_TRUE(provider_state2.got_destruct_);
1326
1327 // Removed at the same time as 2 and therefore not executed.
1328 EXPECT_FALSE(provider_state3.got_on_request_);
1329 EXPECT_FALSE(provider_state3.got_on_request_canceled_);
1330 EXPECT_TRUE(provider_state3.got_destruct_);
1331
1332 EXPECT_TRUE(provider_state4.got_on_request_);
1333 EXPECT_TRUE(provider_state4.got_on_request_canceled_);
1334 EXPECT_TRUE(provider_state4.got_destruct_);
1335}
1336
1337// Test that removal of all providers after continue has the expected results.
1338TEST(ResourceManagerTest, RemoveAllProvidersAfterContinue) {
Googler39a97572023-12-13 22:53:26 +00001339 const char kUrl1[] = "https://test.com/ResourceManagerTest1";
1340 const char kUrl2[] = "https://test.com/ResourceManagerTest2";
1341 const char kUrl3[] = "https://test.com/ResourceManagerTest3";
1342 const char kUrl4[] = "https://test.com/ResourceManagerTest4";
Googler11871152020-10-01 14:59:09 -04001343
1344 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
1345 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
1346 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
1347 const std::string& success4_message = CreateMessage(kDoneMsg, "Success4");
1348 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
1349
1350 ResourceManagerTestHandler::State state;
1351 state.urls_.push_back(kUrl1);
1352 state.urls_.push_back(kUrl2);
1353 state.urls_.push_back(kUrl3);
1354 state.urls_.push_back(kUrl4);
1355
1356 TestProvider::State provider_state1;
1357 TestProvider::State provider_state2;
1358 TestProvider::State provider_state3;
1359 TestProvider::State provider_state4;
1360
1361 ProviderDestructHelper destruct_helper(4);
1362 provider_state1.destruct_callback_ = destruct_helper.callback();
1363 provider_state2.destruct_callback_ = destruct_helper.callback();
1364 provider_state3.destruct_callback_ = destruct_helper.callback();
1365 provider_state4.destruct_callback_ = destruct_helper.callback();
1366
1367 // Resulting order should be sequential; success1 .. success4.
1368 state.manager_->AddProvider(
1369 new OneShotRemovalProvider(&provider_state2,
1370 CreateContents(success2_message),
1371 state.manager_.get(), std::string(), false),
1372 0, std::string());
1373 state.manager_->AddProvider(
1374 new OneShotRemovalProvider(&provider_state1,
1375 CreateContents(success1_message),
1376 state.manager_.get(), std::string(), false),
1377 -100, std::string());
1378 state.manager_->AddProvider(
1379 new OneShotRemovalProvider(&provider_state4,
1380 CreateContents(success4_message),
1381 state.manager_.get(), std::string(), false),
1382 100, std::string());
1383 // Will be removed at the same time as #2 and therefore never called.
1384 state.manager_->AddProvider(
1385 new OneShotRemovalProvider(&provider_state3,
1386 CreateContents(success3_message),
1387 state.manager_.get(), std::string(), false),
1388 0, std::string());
1389
1390 CefRefPtr<ResourceManagerTestHandler> handler =
1391 new ResourceManagerTestHandler(&state);
1392 handler->ExecuteTest();
1393
1394 ReleaseAndWaitForDestructor(handler);
1395
1396 state.manager_ = nullptr;
1397
1398 // Wait for the manager to be deleted.
1399 destruct_helper.Wait();
1400
1401 // Only the 1st provider should complete
1402 EXPECT_EQ(state.messages_.size(), 4U);
1403 EXPECT_EQ(success1_message, state.messages_[0]);
1404 EXPECT_EQ(not_handled_message, state.messages_[1]);
1405 EXPECT_EQ(not_handled_message, state.messages_[2]);
1406 EXPECT_EQ(not_handled_message, state.messages_[3]);
1407
1408 EXPECT_TRUE(provider_state1.got_on_request_);
1409 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1410 EXPECT_TRUE(provider_state1.got_destruct_);
1411
1412 EXPECT_FALSE(provider_state2.got_on_request_);
1413 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1414 EXPECT_TRUE(provider_state2.got_destruct_);
1415
1416 EXPECT_FALSE(provider_state3.got_on_request_);
1417 EXPECT_FALSE(provider_state3.got_on_request_canceled_);
1418 EXPECT_TRUE(provider_state3.got_destruct_);
1419
1420 EXPECT_FALSE(provider_state4.got_on_request_);
1421 EXPECT_FALSE(provider_state4.got_on_request_canceled_);
1422 EXPECT_TRUE(provider_state4.got_destruct_);
1423}
1424
1425// Test that removal of all providers before continue has the expected results.
1426TEST(ResourceManagerTest, RemoveAllProvidersBeforeContinue) {
Googler39a97572023-12-13 22:53:26 +00001427 const char kUrl1[] = "https://test.com/ResourceManagerTest1";
1428 const char kUrl2[] = "https://test.com/ResourceManagerTest2";
1429 const char kUrl3[] = "https://test.com/ResourceManagerTest3";
1430 const char kUrl4[] = "https://test.com/ResourceManagerTest4";
Googler11871152020-10-01 14:59:09 -04001431
1432 const std::string& success1_message = CreateMessage(kDoneMsg, "Success1");
1433 const std::string& success2_message = CreateMessage(kDoneMsg, "Success2");
1434 const std::string& success3_message = CreateMessage(kDoneMsg, "Success3");
1435 const std::string& success4_message = CreateMessage(kDoneMsg, "Success4");
1436 const std::string& not_handled_message = CreateMessage(kDoneMsg, kNotHandled);
1437
1438 ResourceManagerTestHandler::State state;
1439 state.urls_.push_back(kUrl1);
1440 state.urls_.push_back(kUrl2);
1441 state.urls_.push_back(kUrl3);
1442 state.urls_.push_back(kUrl4);
1443
1444 TestProvider::State provider_state1;
1445 TestProvider::State provider_state2;
1446 TestProvider::State provider_state3;
1447 TestProvider::State provider_state4;
1448
1449 ProviderDestructHelper destruct_helper(4);
1450 provider_state1.destruct_callback_ = destruct_helper.callback();
1451 provider_state2.destruct_callback_ = destruct_helper.callback();
1452 provider_state3.destruct_callback_ = destruct_helper.callback();
1453 provider_state4.destruct_callback_ = destruct_helper.callback();
1454
1455 // Resulting order should be sequential; success1 .. success4.
1456 state.manager_->AddProvider(
1457 new OneShotRemovalProvider(&provider_state2,
1458 CreateContents(success2_message),
1459 state.manager_.get(), std::string(), true),
1460 0, std::string());
1461 state.manager_->AddProvider(
1462 new OneShotRemovalProvider(&provider_state1,
1463 CreateContents(success1_message),
1464 state.manager_.get(), std::string(), true),
1465 -100, std::string());
1466 state.manager_->AddProvider(
1467 new OneShotRemovalProvider(&provider_state4,
1468 CreateContents(success4_message),
1469 state.manager_.get(), std::string(), true),
1470 100, std::string());
1471 // Will be removed at the same time as #2 and therefore never called.
1472 state.manager_->AddProvider(
1473 new OneShotRemovalProvider(&provider_state3,
1474 CreateContents(success3_message),
1475 state.manager_.get(), std::string(), true),
1476 0, std::string());
1477
1478 CefRefPtr<ResourceManagerTestHandler> handler =
1479 new ResourceManagerTestHandler(&state);
1480 handler->ExecuteTest();
1481
1482 ReleaseAndWaitForDestructor(handler);
1483
1484 state.manager_ = nullptr;
1485
1486 // Wait for the manager to be deleted.
1487 destruct_helper.Wait();
1488
1489 // No providers should complete.
1490 EXPECT_EQ(state.messages_.size(), 4U);
1491 EXPECT_EQ(not_handled_message, state.messages_[0]);
1492 EXPECT_EQ(not_handled_message, state.messages_[1]);
1493 EXPECT_EQ(not_handled_message, state.messages_[2]);
1494 EXPECT_EQ(not_handled_message, state.messages_[3]);
1495
1496 // 1st provider should also be canceled.
1497 EXPECT_TRUE(provider_state1.got_on_request_);
1498 EXPECT_TRUE(provider_state1.got_on_request_canceled_);
1499 EXPECT_TRUE(provider_state1.got_destruct_);
1500
1501 EXPECT_FALSE(provider_state2.got_on_request_);
1502 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1503 EXPECT_TRUE(provider_state2.got_destruct_);
1504
1505 EXPECT_FALSE(provider_state3.got_on_request_);
1506 EXPECT_FALSE(provider_state3.got_on_request_canceled_);
1507 EXPECT_TRUE(provider_state3.got_destruct_);
1508
1509 EXPECT_FALSE(provider_state4.got_on_request_);
1510 EXPECT_FALSE(provider_state4.got_on_request_canceled_);
1511 EXPECT_TRUE(provider_state4.got_destruct_);
1512}
1513
1514namespace {
1515
1516// Test the URL filter capability.
1517class UrlFilterTestProvider : public TestProvider {
1518 public:
1519 UrlFilterTestProvider(State* state,
1520 const std::string& expected_url,
1521 const std::string& expected_url_after_filter)
1522 : TestProvider(state),
1523 expected_url_(expected_url),
1524 expected_url_after_filter_(expected_url_after_filter) {}
1525
1526 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
1527 TestProvider::OnRequest(request);
1528
1529 // Request::url is already filtered.
1530 EXPECT_EQ(expected_url_, request->url());
1531
1532 // Explicitly filter the URL again.
1533 const std::string& filtered_url =
1534 request->url_filter().Run(request->request()->GetURL());
1535 EXPECT_EQ(expected_url_after_filter_, filtered_url);
1536
1537 request->Continue(nullptr);
1538 return true;
1539 }
1540
1541 private:
1542 std::string expected_url_;
1543 std::string expected_url_after_filter_;
1544 DISALLOW_COPY_AND_ASSIGN(UrlFilterTestProvider);
1545};
1546
1547std::string TestUrlFilter(const std::string& url) {
1548 return url + "Rewrite";
1549}
1550
1551// Add to the URL but keep the query component.
1552std::string TestUrlFilterWithQuery(const std::string& url) {
1553 size_t pos = url.find('?');
Googler39a97572023-12-13 22:53:26 +00001554 if (pos == std::string::npos) {
Googler11871152020-10-01 14:59:09 -04001555 return url;
Googler39a97572023-12-13 22:53:26 +00001556 }
Googler11871152020-10-01 14:59:09 -04001557 return url.substr(0, pos) + "Rewrite" + url.substr(pos);
1558}
1559
1560// Add to the URL but keep the fragment component.
1561std::string TestUrlFilterWithFragment(const std::string& url) {
1562 size_t pos = url.find('#');
Googler39a97572023-12-13 22:53:26 +00001563 if (pos == std::string::npos) {
Googler11871152020-10-01 14:59:09 -04001564 return url;
Googler39a97572023-12-13 22:53:26 +00001565 }
Googler11871152020-10-01 14:59:09 -04001566 return url.substr(0, pos) + "Rewrite" + url.substr(pos);
1567}
1568
1569} // namespace
1570
1571// Test the URL filter capability.
1572TEST(ResourceManagerTest, UrlFilter) {
Googler39a97572023-12-13 22:53:26 +00001573 const char kUrl[] = "https://test.com/ResourceManagerTest";
1574 const char kExpectedUrl[] = "https://test.com/ResourceManagerTestRewrite";
Googler11871152020-10-01 14:59:09 -04001575
1576 ResourceManagerTestHandler::State state;
1577 state.urls_.push_back(kUrl);
1578
1579 // Set the URL filter.
Googler39a97572023-12-13 22:53:26 +00001580 state.manager_->SetUrlFilter(base::BindRepeating(TestUrlFilter));
Googler11871152020-10-01 14:59:09 -04001581
1582 TestProvider::State provider_state1;
1583 TestProvider::State provider_state2;
1584
1585 ProviderDestructHelper destruct_helper(2);
1586 provider_state1.destruct_callback_ = destruct_helper.callback();
1587 provider_state2.destruct_callback_ = destruct_helper.callback();
1588
1589 state.manager_->AddProvider(
1590 new UrlFilterTestProvider(&provider_state1, kExpectedUrl, kExpectedUrl),
1591 0, std::string());
1592 state.manager_->AddProvider(
1593 new UrlFilterTestProvider(&provider_state2, kExpectedUrl, kExpectedUrl),
1594 0, std::string());
1595
1596 CefRefPtr<ResourceManagerTestHandler> handler =
1597 new ResourceManagerTestHandler(&state);
1598 handler->ExecuteTest();
1599
1600 ReleaseAndWaitForDestructor(handler);
1601
1602 state.manager_ = nullptr;
1603
1604 // Wait for the manager to be deleted.
1605 destruct_helper.Wait();
1606
1607 // All providers are called.
1608 EXPECT_TRUE(provider_state1.got_on_request_);
1609 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1610 EXPECT_TRUE(provider_state1.got_destruct_);
1611
1612 EXPECT_TRUE(provider_state2.got_on_request_);
1613 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1614 EXPECT_TRUE(provider_state2.got_destruct_);
1615
1616 EXPECT_EQ(state.messages_.size(), 1U);
1617 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
1618}
1619
1620// Test the URL filter capability with a query component.
1621TEST(ResourceManagerTest, UrlFilterWithQuery) {
Googler39a97572023-12-13 22:53:26 +00001622 const char kUrl[] = "https://test.com/ResourceManagerTest?foo=bar";
1623 const char kExpectedUrl[] = "https://test.com/ResourceManagerTestRewrite";
Googler11871152020-10-01 14:59:09 -04001624 const char kExpectedUrlAfterFilter[] =
Googler39a97572023-12-13 22:53:26 +00001625 "https://test.com/ResourceManagerTestRewrite?foo=bar";
Googler11871152020-10-01 14:59:09 -04001626
1627 ResourceManagerTestHandler::State state;
1628 state.urls_.push_back(kUrl);
1629
1630 // Set the URL filter.
Googler39a97572023-12-13 22:53:26 +00001631 state.manager_->SetUrlFilter(base::BindRepeating(TestUrlFilterWithQuery));
Googler11871152020-10-01 14:59:09 -04001632
1633 TestProvider::State provider_state1;
1634 TestProvider::State provider_state2;
1635
1636 ProviderDestructHelper destruct_helper(2);
1637 provider_state1.destruct_callback_ = destruct_helper.callback();
1638 provider_state2.destruct_callback_ = destruct_helper.callback();
1639
1640 state.manager_->AddProvider(
1641 new UrlFilterTestProvider(&provider_state1, kExpectedUrl,
1642 kExpectedUrlAfterFilter),
1643 0, std::string());
1644 state.manager_->AddProvider(
1645 new UrlFilterTestProvider(&provider_state2, kExpectedUrl,
1646 kExpectedUrlAfterFilter),
1647 0, std::string());
1648
1649 CefRefPtr<ResourceManagerTestHandler> handler =
1650 new ResourceManagerTestHandler(&state);
1651 handler->ExecuteTest();
1652
1653 ReleaseAndWaitForDestructor(handler);
1654
1655 state.manager_ = nullptr;
1656
1657 // Wait for the manager to be deleted.
1658 destruct_helper.Wait();
1659
1660 // All providers are called.
1661 EXPECT_TRUE(provider_state1.got_on_request_);
1662 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1663 EXPECT_TRUE(provider_state1.got_destruct_);
1664
1665 EXPECT_TRUE(provider_state2.got_on_request_);
1666 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1667 EXPECT_TRUE(provider_state2.got_destruct_);
1668
1669 EXPECT_EQ(state.messages_.size(), 1U);
1670 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
1671}
1672
1673// Test the URL filter capability with a fragment component.
1674TEST(ResourceManagerTest, UrlFilterWithFragment) {
1675 // Fragment components will not be passed with the request.
Googler39a97572023-12-13 22:53:26 +00001676 const char kUrl[] = "https://test.com/ResourceManagerTest#fragment";
1677 const char kExpectedUrl[] = "https://test.com/ResourceManagerTestRewrite";
Googler11871152020-10-01 14:59:09 -04001678 const char kExpectedUrlAfterFilter[] =
Googler39a97572023-12-13 22:53:26 +00001679 "https://test.com/ResourceManagerTestRewrite#fragment";
Googler11871152020-10-01 14:59:09 -04001680
1681 ResourceManagerTestHandler::State state;
1682 state.urls_.push_back(kUrl);
1683
1684 // Set the URL filter.
Googler39a97572023-12-13 22:53:26 +00001685 state.manager_->SetUrlFilter(base::BindRepeating(TestUrlFilterWithFragment));
Googler11871152020-10-01 14:59:09 -04001686
1687 TestProvider::State provider_state1;
1688 TestProvider::State provider_state2;
1689
1690 ProviderDestructHelper destruct_helper(2);
1691 provider_state1.destruct_callback_ = destruct_helper.callback();
1692 provider_state2.destruct_callback_ = destruct_helper.callback();
1693
1694 state.manager_->AddProvider(
1695 new UrlFilterTestProvider(&provider_state1, kExpectedUrl,
1696 kExpectedUrlAfterFilter),
1697 0, std::string());
1698 state.manager_->AddProvider(
1699 new UrlFilterTestProvider(&provider_state2, kExpectedUrl,
1700 kExpectedUrlAfterFilter),
1701 0, std::string());
1702
1703 CefRefPtr<ResourceManagerTestHandler> handler =
1704 new ResourceManagerTestHandler(&state);
1705 handler->ExecuteTest();
1706
1707 ReleaseAndWaitForDestructor(handler);
1708
1709 state.manager_ = nullptr;
1710
1711 // Wait for the manager to be deleted.
1712 destruct_helper.Wait();
1713
1714 // All providers are called.
1715 EXPECT_TRUE(provider_state1.got_on_request_);
1716 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1717 EXPECT_TRUE(provider_state1.got_destruct_);
1718
1719 EXPECT_TRUE(provider_state2.got_on_request_);
1720 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1721 EXPECT_TRUE(provider_state2.got_destruct_);
1722
1723 EXPECT_EQ(state.messages_.size(), 1U);
1724 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
1725}
1726
1727namespace {
1728
1729// Test the mime type resolver capability.
1730class MimeTypeTestProvider : public TestProvider {
1731 public:
1732 MimeTypeTestProvider(State* state, const std::string& expected_mime_type)
1733 : TestProvider(state), expected_mime_type_(expected_mime_type) {}
1734
1735 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
1736 TestProvider::OnRequest(request);
1737
1738 const std::string& mime_type =
1739 request->mime_type_resolver().Run(request->url());
1740 EXPECT_EQ(expected_mime_type_, mime_type);
1741
1742 request->Continue(nullptr);
1743 return true;
1744 }
1745
1746 private:
1747 std::string expected_mime_type_;
1748 DISALLOW_COPY_AND_ASSIGN(MimeTypeTestProvider);
1749};
1750
1751const char kExpectedMimeType[] = "foo/bar";
1752
1753std::string TestMimeTypeResolver(const std::string& url) {
1754 return kExpectedMimeType;
1755}
1756
1757} // namespace
1758
1759// Test the mime type resolver capability.
1760TEST(ResourceManagerTest, MimeTypeResolver) {
Googler39a97572023-12-13 22:53:26 +00001761 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -04001762
1763 ResourceManagerTestHandler::State state;
1764 state.urls_.push_back(kUrl);
1765
1766 // Set the mime type resolver.
Googler39a97572023-12-13 22:53:26 +00001767 state.manager_->SetMimeTypeResolver(
1768 base::BindRepeating(TestMimeTypeResolver));
Googler11871152020-10-01 14:59:09 -04001769
1770 TestProvider::State provider_state1;
1771 TestProvider::State provider_state2;
1772
1773 ProviderDestructHelper destruct_helper(2);
1774 provider_state1.destruct_callback_ = destruct_helper.callback();
1775 provider_state2.destruct_callback_ = destruct_helper.callback();
1776
1777 state.manager_->AddProvider(
1778 new MimeTypeTestProvider(&provider_state1, kExpectedMimeType), 0,
1779 std::string());
1780 state.manager_->AddProvider(
1781 new MimeTypeTestProvider(&provider_state2, kExpectedMimeType), 0,
1782 std::string());
1783
1784 CefRefPtr<ResourceManagerTestHandler> handler =
1785 new ResourceManagerTestHandler(&state);
1786 handler->ExecuteTest();
1787
1788 ReleaseAndWaitForDestructor(handler);
1789
1790 state.manager_ = nullptr;
1791
1792 // Wait for the manager to be deleted.
1793 destruct_helper.Wait();
1794
1795 // All providers are called.
1796 EXPECT_TRUE(provider_state1.got_on_request_);
1797 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1798 EXPECT_TRUE(provider_state1.got_destruct_);
1799
1800 EXPECT_TRUE(provider_state2.got_on_request_);
1801 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1802 EXPECT_TRUE(provider_state2.got_destruct_);
1803
1804 EXPECT_EQ(state.messages_.size(), 1U);
1805 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
1806}
1807
1808namespace {
1809
1810// Content provider that adds another provider before or after the current
1811// provider.
1812class AddingTestProvider : public TestProvider {
1813 public:
1814 AddingTestProvider(State* state,
1815 State* new_state,
1816 CefResourceManager* manager,
1817 bool before)
1818 : TestProvider(state),
1819 new_state_(new_state),
1820 manager_(manager),
1821 before_(before) {}
1822
1823 bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
1824 TestProvider::OnRequest(request);
1825
1826 manager_->AddProvider(
1827 new SimpleTestProvider(new_state_, SimpleTestProvider::CONTINUE,
1828 nullptr),
1829 before_ ? -1 : 1, std::string());
1830
1831 request->Continue(nullptr);
1832 return true;
1833 }
1834
1835 private:
1836 State* new_state_;
1837 CefResourceManager* manager_; // Weak reference.
1838 bool before_;
1839
1840 DISALLOW_COPY_AND_ASSIGN(AddingTestProvider);
1841};
1842
1843} // namespace
1844
1845// Test adding a new provider after the current provider.
1846TEST(ResourceManagerTest, AddProviderAfter) {
Googler39a97572023-12-13 22:53:26 +00001847 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -04001848
1849 ResourceManagerTestHandler::State state;
1850 state.urls_.push_back(kUrl);
1851
1852 TestProvider::State provider_state1;
1853 TestProvider::State provider_state2;
1854
1855 ProviderDestructHelper destruct_helper(2);
1856 provider_state1.destruct_callback_ = destruct_helper.callback();
1857 provider_state2.destruct_callback_ = destruct_helper.callback();
1858
1859 state.manager_->AddProvider(
1860 new AddingTestProvider(&provider_state1, &provider_state2,
1861 state.manager_.get(), false),
1862 0, std::string());
1863
1864 CefRefPtr<ResourceManagerTestHandler> handler =
1865 new ResourceManagerTestHandler(&state);
1866 handler->ExecuteTest();
1867
1868 ReleaseAndWaitForDestructor(handler);
1869
1870 state.manager_ = nullptr;
1871
1872 // Wait for the manager to be deleted.
1873 destruct_helper.Wait();
1874
1875 // All providers are called.
1876 EXPECT_TRUE(provider_state1.got_on_request_);
1877 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1878 EXPECT_TRUE(provider_state1.got_destruct_);
1879
1880 EXPECT_TRUE(provider_state2.got_on_request_);
1881 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1882 EXPECT_TRUE(provider_state2.got_destruct_);
1883
1884 EXPECT_EQ(state.messages_.size(), 1U);
1885 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
1886}
1887
1888// Test adding a new provider before the current provider.
1889TEST(ResourceManagerTest, AddProviderBefore) {
Googler39a97572023-12-13 22:53:26 +00001890 const char kUrl[] = "https://test.com/ResourceManagerTest";
Googler11871152020-10-01 14:59:09 -04001891
1892 ResourceManagerTestHandler::State state;
1893 state.urls_.push_back(kUrl);
1894
1895 TestProvider::State provider_state1;
1896 TestProvider::State provider_state2;
1897
1898 ProviderDestructHelper destruct_helper(2);
1899 provider_state1.destruct_callback_ = destruct_helper.callback();
1900 provider_state2.destruct_callback_ = destruct_helper.callback();
1901
1902 state.manager_->AddProvider(
1903 new AddingTestProvider(&provider_state1, &provider_state2,
1904 state.manager_.get(), true),
1905 0, std::string());
1906
1907 CefRefPtr<ResourceManagerTestHandler> handler =
1908 new ResourceManagerTestHandler(&state);
1909 handler->ExecuteTest();
1910
1911 ReleaseAndWaitForDestructor(handler);
1912
1913 state.manager_ = nullptr;
1914
1915 // Wait for the manager to be deleted.
1916 destruct_helper.Wait();
1917
1918 // 1st provider is called.
1919 EXPECT_TRUE(provider_state1.got_on_request_);
1920 EXPECT_FALSE(provider_state1.got_on_request_canceled_);
1921 EXPECT_TRUE(provider_state1.got_destruct_);
1922
1923 // 2nd provider is not called because it was added before the 1st provider.
1924 EXPECT_FALSE(provider_state2.got_on_request_);
1925 EXPECT_FALSE(provider_state2.got_on_request_canceled_);
1926 EXPECT_TRUE(provider_state2.got_destruct_);
1927
1928 EXPECT_EQ(state.messages_.size(), 1U);
1929 EXPECT_EQ(CreateMessage(kDoneMsg, kNotHandled), state.messages_[0]);
1930}