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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
// Copyright (c) 2012 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.
// See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
#ifndef CONTENT_CHILD_RESOURCE_DISPATCHER_H_
#define CONTENT_CHILD_RESOURCE_DISPATCHER_H_
#include <deque>
#include <string>
#include "base/containers/hash_tables.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/shared_memory.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "content/common/content_export.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
#include "webkit/child/resource_loader_bridge.h"
struct ResourceMsg_RequestCompleteData;
namespace content {
class ResourceDispatcherDelegate;
struct ResourceResponseHead;
struct SiteIsolationResponseMetaData;
// This class serves as a communication interface between the
// ResourceDispatcherHost in the browser process and the ResourceLoaderBridge in
// the child process. It can be used from any child process.
class CONTENT_EXPORT ResourceDispatcher : public IPC::Listener {
public:
explicit ResourceDispatcher(IPC::Sender* sender);
virtual ~ResourceDispatcher();
// IPC::Listener implementation.
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
// Creates a ResourceLoaderBridge for this type of dispatcher, this is so
// this can be tested regardless of the ResourceLoaderBridge::Create
// implementation.
webkit_glue::ResourceLoaderBridge* CreateBridge(
const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info);
// Adds a request from the pending_requests_ list, returning the new
// requests' ID
int AddPendingRequest(webkit_glue::ResourceLoaderBridge::Peer* callback,
ResourceType::Type resource_type,
int origin_pid,
const GURL& frame_origin,
const GURL& request_url);
// Removes a request from the pending_requests_ list, returning true if the
// request was found and removed.
bool RemovePendingRequest(int request_id);
// Cancels a request in the pending_requests_ list.
void CancelPendingRequest(int request_id);
IPC::Sender* message_sender() const {
return message_sender_;
}
// Toggles the is_deferred attribute for the specified request.
void SetDefersLoading(int request_id, bool value);
// Indicates the priority of the specified request changed.
void DidChangePriority(int routing_id, int request_id,
net::RequestPriority new_priority);
// This does not take ownership of the delegate. It is expected that the
// delegate have a longer lifetime than the ResourceDispatcher.
void set_delegate(ResourceDispatcherDelegate* delegate) {
delegate_ = delegate;
}
// Remembers IO thread timestamp for next resource message.
void set_io_timestamp(base::TimeTicks io_timestamp) {
io_timestamp_ = io_timestamp;
}
private:
friend class ResourceDispatcherTest;
typedef std::deque<IPC::Message*> MessageQueue;
struct PendingRequestInfo {
PendingRequestInfo();
PendingRequestInfo(webkit_glue::ResourceLoaderBridge::Peer* peer,
ResourceType::Type resource_type,
int origin_pid,
const GURL& frame_origin,
const GURL& request_url);
~PendingRequestInfo();
webkit_glue::ResourceLoaderBridge::Peer* peer;
ResourceType::Type resource_type;
// The PID of the original process which issued this request. This gets
// non-zero only for a request proxied by another renderer, particularly
// requests from plugins.
int origin_pid;
MessageQueue deferred_message_queue;
bool is_deferred;
// Original requested url.
GURL url;
// The security origin of the frame that initiates this request.
GURL frame_origin;
// The url of the latest response even in case of redirection.
GURL response_url;
linked_ptr<IPC::Message> pending_redirect_message;
base::TimeTicks request_start;
base::TimeTicks response_start;
base::TimeTicks completion_time;
linked_ptr<base::SharedMemory> buffer;
linked_ptr<SiteIsolationResponseMetaData> site_isolation_metadata;
bool blocked_response;
int buffer_size;
};
typedef base::hash_map<int, PendingRequestInfo> PendingRequestList;
// Helper to lookup the info based on the request_id.
// May return NULL if the request as been canceled from the client side.
PendingRequestInfo* GetPendingRequestInfo(int request_id);
// Follows redirect, if any, for the given request.
void FollowPendingRedirect(int request_id, PendingRequestInfo& request_info);
// Message response handlers, called by the message handler for this process.
void OnUploadProgress(
int request_id,
int64 position,
int64 size);
void OnReceivedResponse(int request_id, const ResourceResponseHead&);
void OnReceivedCachedMetadata(int request_id, const std::vector<char>& data);
void OnReceivedRedirect(
int request_id,
const GURL& new_url,
const ResourceResponseHead& response_head);
void OnSetDataBuffer(
int request_id,
base::SharedMemoryHandle shm_handle,
int shm_size,
base::ProcessId renderer_pid);
void OnReceivedData(
int request_id,
int data_offset,
int data_length,
int encoded_data_length);
void OnDownloadedData(
int request_id,
int data_len,
int encoded_data_length);
void OnRequestComplete(
int request_id,
const ResourceMsg_RequestCompleteData &request_complete_data);
// Dispatch the message to one of the message response handlers.
void DispatchMessage(const IPC::Message& message);
// Dispatch any deferred messages for the given request, provided it is not
// again in the deferred state.
void FlushDeferredMessages(int request_id);
void ToResourceResponseInfo(
const PendingRequestInfo& request_info,
const ResourceResponseHead& browser_info,
webkit_glue::ResourceResponseInfo* renderer_info) const;
base::TimeTicks ToRendererCompletionTime(
const PendingRequestInfo& request_info,
const base::TimeTicks& browser_completion_time) const;
// Returns timestamp provided by IO thread. If no timestamp is supplied,
// then current time is returned. Saved timestamp is reset, so following
// invocations will return current time until set_io_timestamp is called.
base::TimeTicks ConsumeIOTimestamp();
// Returns true if the message passed in is a resource related message.
static bool IsResourceDispatcherMessage(const IPC::Message& message);
// ViewHostMsg_Resource_DataReceived is not POD, it has a shared memory
// handle in it that we should cleanup it up nicely. This method accepts any
// message and determine whether the message is
// ViewHostMsg_Resource_DataReceived and clean up the shared memory handle.
static void ReleaseResourcesInDataMessage(const IPC::Message& message);
// Iterate through a message queue and clean up the messages by calling
// ReleaseResourcesInDataMessage and removing them from the queue. Intended
// for use on deferred message queues that are no longer needed.
static void ReleaseResourcesInMessageQueue(MessageQueue* queue);
IPC::Sender* message_sender_;
// All pending requests issued to the host
PendingRequestList pending_requests_;
base::WeakPtrFactory<ResourceDispatcher> weak_factory_;
ResourceDispatcherDelegate* delegate_;
// IO thread timestamp for ongoing IPC message.
base::TimeTicks io_timestamp_;
DISALLOW_COPY_AND_ASSIGN(ResourceDispatcher);
};
} // namespace content
#endif // CONTENT_CHILD_RESOURCE_DISPATCHER_H_
|