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
|
// 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_COMMON_RESOURCE_DISPATCHER_H_
#define CONTENT_COMMON_RESOURCE_DISPATCHER_H_
#pragma once
#include <deque>
#include <string>
#include "base/hash_tables.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/shared_memory.h"
#include "base/time.h"
#include "content/common/content_export.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
#include "webkit/glue/resource_loader_bridge.h"
namespace content {
class ResourceDispatcherDelegate;
struct ResourceResponseHead;
// 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,
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 routing_id, 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);
// 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;
}
private:
friend class ResourceDispatcherTest;
typedef std::deque<IPC::Message*> MessageQueue;
struct PendingRequestInfo {
PendingRequestInfo()
: peer(NULL),
resource_type(ResourceType::SUB_RESOURCE),
is_deferred(false) {
}
PendingRequestInfo(webkit_glue::ResourceLoaderBridge::Peer* peer,
ResourceType::Type resource_type,
const GURL& request_url)
: peer(peer),
resource_type(resource_type),
is_deferred(false),
url(request_url),
request_start(base::TimeTicks::Now()) {
}
~PendingRequestInfo() {}
webkit_glue::ResourceLoaderBridge::Peer* peer;
ResourceType::Type resource_type;
MessageQueue deferred_message_queue;
bool is_deferred;
GURL url;
linked_ptr<IPC::Message> pending_redirect_message;
base::TimeTicks request_start;
base::TimeTicks response_start;
base::TimeTicks completion_time;
};
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(
const IPC::Message& message,
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(
const IPC::Message& message,
int request_id,
const GURL& new_url,
const ResourceResponseHead& response_head);
void OnReceivedData(
const IPC::Message& message,
int request_id,
base::SharedMemoryHandle data,
int data_len,
int encoded_data_length);
void OnDownloadedData(
const IPC::Message& message,
int request_id,
int data_len);
void OnRequestComplete(
int request_id,
const net::URLRequestStatus& status,
const std::string& security_info,
const base::TimeTicks& completion_time);
// 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 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_;
DISALLOW_COPY_AND_ASSIGN(ResourceDispatcher);
};
} // namespace content
#endif // CONTENT_COMMON_RESOURCE_DISPATCHER_H_
|
