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
content / renderer / pepper / pepper_url_loader_host.h [blame]
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_RENDERER_PEPPER_PEPPER_URL_LOADER_HOST_H_
#define CONTENT_RENDERER_PEPPER_PEPPER_URL_LOADER_HOST_H_
#include <stdint.h>
#include <memory>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "ppapi/host/resource_host.h"
#include "ppapi/proxy/resource_message_params.h"
#include "ppapi/shared_impl/url_request_info_data.h"
#include "ppapi/shared_impl/url_response_info_data.h"
#include "third_party/blink/public/web/web_associated_url_loader_client.h"
namespace blink {
class WebAssociatedURLLoader;
class WebLocalFrame;
} // namespace blink
namespace content {
class RendererPpapiHostImpl;
class PepperURLLoaderHost : public ppapi::host::ResourceHost,
public blink::WebAssociatedURLLoaderClient {
public:
// If main_document_loader is true, PP_Resource must be 0 since it will be
// pending until the plugin resource attaches to it.
PepperURLLoaderHost(RendererPpapiHostImpl* host,
bool main_document_loader,
PP_Instance instance,
PP_Resource resource);
PepperURLLoaderHost(const PepperURLLoaderHost&) = delete;
PepperURLLoaderHost& operator=(const PepperURLLoaderHost&) = delete;
~PepperURLLoaderHost() override;
// ResourceHost implementation.
int32_t OnResourceMessageReceived(
const IPC::Message& msg,
ppapi::host::HostMessageContext* context) override;
// blink::WebAssociatedURLLoaderClient implementation.
bool WillFollowRedirect(const blink::WebURL& new_url,
const blink::WebURLResponse& redir_response) override;
void DidSendData(uint64_t bytes_sent,
uint64_t total_bytes_to_be_sent) override;
void DidReceiveResponse(const blink::WebURLResponse& response) override;
void DidDownloadData(uint64_t data_length) override;
void DidReceiveData(base::span<const char> data) override;
void DidFinishLoading() override;
void DidFail(const blink::WebURLError& error) override;
private:
// ResourceHost protected overrides.
void DidConnectPendingHostToResource() override;
// IPC messages
int32_t OnHostMsgOpen(ppapi::host::HostMessageContext* context,
const ppapi::URLRequestInfoData& request_data);
int32_t InternalOnHostMsgOpen(ppapi::host::HostMessageContext* context,
const ppapi::URLRequestInfoData& request_data);
int32_t OnHostMsgSetDeferLoading(ppapi::host::HostMessageContext* context,
bool defers_loading);
int32_t OnHostMsgClose(ppapi::host::HostMessageContext* context);
int32_t OnHostMsgGrantUniversalAccess(
ppapi::host::HostMessageContext* context);
// Sends or queues an unsolicited message to the plugin resource. This
// handles cases where messages must be reordered for the plugin and
// the case where we have created a pending host resource and the
// plugin has not connected to us yet.
//
// Takes ownership of the given pointer.
void SendUpdateToPlugin(std::unique_ptr<IPC::Message> msg);
// Sends or queues an unsolicited message to the plugin resource. This is
// used inside SendUpdateToPlugin for messages that are already ordered
// properly.
//
// Takes ownership of the given pointer.
void SendOrderedUpdateToPlugin(std::unique_ptr<IPC::Message> msg);
void Close();
// Returns the frame for the current request.
blink::WebLocalFrame* GetFrame();
// Calls SetDefersLoading on the current load. This encapsulates the logic
// differences between document loads and regular ones.
void SetDefersLoading(bool defers_loading);
// Converts a WebURLResponse to a URLResponseInfo and saves it.
void SaveResponse(const blink::WebURLResponse& response);
// Sends the UpdateProgress message (if necessary) to the plugin.
void UpdateProgress();
// Non-owning pointer.
raw_ptr<RendererPpapiHostImpl> renderer_ppapi_host_;
// If true, then the plugin instance is a full-frame plugin and we're just
// wrapping the main document's loader (i.e. loader_ is null).
bool main_document_loader_;
// The data that generated the request.
ppapi::URLRequestInfoData request_data_;
// Set to true when this loader can ignore same originl policy.
bool has_universal_access_;
// The loader associated with this request. MAY BE NULL.
//
// This will be NULL if the load hasn't been opened yet, or if this is a main
// document loader (when registered as a mime type). Therefore, you should
// always NULL check this value before using it. In the case of a main
// document load, you would call the functions on the document to cancel the
// load, etc. since there is no loader.
std::unique_ptr<blink::WebAssociatedURLLoader> loader_;
int64_t bytes_sent_;
int64_t total_bytes_to_be_sent_;
int64_t bytes_received_;
int64_t total_bytes_to_be_received_;
// Messages sent while the resource host is pending. These will be forwarded
// to the plugin when the plugin side connects. The pointers are owned by
// this object and must be deleted.
std::vector<std::unique_ptr<IPC::Message>> pending_replies_;
std::vector<std::unique_ptr<IPC::Message>> out_of_order_replies_;
// True when there's a pending DataFromURLResponse call which will send a
// PpapiPluginMsg_URLLoader_ReceivedResponse to the plugin, which introduces
// ordering constraints on following messages to the plugin.
bool pending_response_;
};
} // namespace content
#endif // CONTENT_RENDERER_PEPPER_PEPPER_URL_LOADER_HOST_H_