1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_TESTING_MOCK_FETCH_CONTEXT_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_TESTING_MOCK_FETCH_CONTEXT_H_
#include "base/optional.h"
#include "base/single_thread_task_runner.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/public/platform/web_url_loader_factory.h"
#include "third_party/blink/renderer/platform/exported/wrapped_resource_request.h"
#include "third_party/blink/renderer/platform/loader/fetch/fetch_context.h"
#include "third_party/blink/renderer/platform/loader/fetch/fetch_parameters.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_timing_info.h"
#include "third_party/blink/renderer/platform/scheduler/public/frame_scheduler.h"
#include "third_party/blink/renderer/platform/scheduler/test/fake_frame_scheduler.h"
#include "third_party/blink/renderer/platform/scheduler/test/fake_task_runner.h"
#include <memory>
namespace blink {
class KURL;
class ResourceRequest;
struct ResourceLoaderOptions;
// Mocked FetchContext for testing.
class MockFetchContext : public FetchContext {
public:
enum LoadPolicy {
kShouldLoadNewResource,
kShouldNotLoadNewResource,
};
static MockFetchContext* Create(LoadPolicy load_policy,
scoped_refptr<base::SingleThreadTaskRunner>
loading_task_runner = nullptr) {
return new MockFetchContext(load_policy, std::move(loading_task_runner));
}
~MockFetchContext() override = default;
void SetLoadComplete(bool complete) { complete_ = complete; }
long long GetTransferSize() const { return transfer_size_; }
const SecurityOrigin* GetSecurityOrigin() const override {
return security_origin_.get();
}
void SetSecurityOrigin(scoped_refptr<const SecurityOrigin> security_origin) {
security_origin_ = security_origin;
}
// The last ResourceRequest passed to DispatchWillSendRequest.
base::Optional<ResourceRequest> RequestFromWillSendRequest() const {
return will_send_request_;
}
// FetchContext:
void DispatchWillSendRequest(
unsigned long identifier,
ResourceRequest& request,
const ResourceResponse& redirect_response,
Resource::Type,
const FetchInitiatorInfo& = FetchInitiatorInfo()) override {
will_send_request_ = request;
}
bool AllowImage(bool images_enabled, const KURL&) const override {
return true;
}
base::Optional<ResourceRequestBlockedReason> CanRequest(
Resource::Type,
const ResourceRequest&,
const KURL&,
const ResourceLoaderOptions&,
SecurityViolationReportingPolicy,
ResourceRequest::RedirectStatus redirect_status) const override {
return base::nullopt;
}
base::Optional<ResourceRequestBlockedReason> CheckCSPForRequest(
WebURLRequest::RequestContext,
const KURL& url,
const ResourceLoaderOptions& options,
SecurityViolationReportingPolicy reporting_policy,
ResourceRequest::RedirectStatus redirect_status) const override {
return base::nullopt;
}
bool ShouldLoadNewResource(Resource::Type) const override {
return load_policy_ == kShouldLoadNewResource;
}
bool IsLoadComplete() const override { return complete_; }
void AddResourceTiming(
const ResourceTimingInfo& resource_timing_info) override {
transfer_size_ = resource_timing_info.TransferSize();
}
std::unique_ptr<WebURLLoader> CreateURLLoader(
const ResourceRequest& request,
const ResourceLoaderOptions&) override {
if (!url_loader_factory_) {
url_loader_factory_ =
Platform::Current()->CreateDefaultURLLoaderFactory();
}
WrappedResourceRequest wrapped(request);
return url_loader_factory_->CreateURLLoader(
wrapped, CreateResourceLoadingTaskRunnerHandle());
}
ResourceLoadScheduler::ThrottlingPolicy InitialLoadThrottlingPolicy()
const override {
return ResourceLoadScheduler::ThrottlingPolicy::kTight;
}
FrameScheduler* GetFrameScheduler() const override {
return frame_scheduler_.get();
}
scoped_refptr<base::SingleThreadTaskRunner> GetLoadingTaskRunner() override {
return frame_scheduler_->GetTaskRunner(TaskType::kInternalTest);
}
std::unique_ptr<blink::scheduler::WebResourceLoadingTaskRunnerHandle>
CreateResourceLoadingTaskRunnerHandle() override {
return scheduler::WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
GetLoadingTaskRunner());
}
private:
class MockFrameScheduler final : public scheduler::FakeFrameScheduler {
public:
explicit MockFrameScheduler(
scoped_refptr<base::SingleThreadTaskRunner> runner)
: runner_(std::move(runner)) {}
scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner(
TaskType) override {
return runner_;
}
private:
scoped_refptr<base::SingleThreadTaskRunner> runner_;
};
MockFetchContext(
LoadPolicy load_policy,
scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner)
: load_policy_(load_policy),
runner_(loading_task_runner
? std::move(loading_task_runner)
: base::MakeRefCounted<scheduler::FakeTaskRunner>()),
security_origin_(SecurityOrigin::CreateUniqueOpaque()),
frame_scheduler_(new MockFrameScheduler(runner_)),
complete_(false),
transfer_size_(-1) {}
enum LoadPolicy load_policy_;
scoped_refptr<base::SingleThreadTaskRunner> runner_;
scoped_refptr<const SecurityOrigin> security_origin_;
std::unique_ptr<FrameScheduler> frame_scheduler_;
std::unique_ptr<WebURLLoaderFactory> url_loader_factory_;
bool complete_;
long long transfer_size_;
base::Optional<ResourceRequest> will_send_request_;
};
} // namespace blink
#endif
|
