content/browser/renderer_host/throttling_resource_handler.cc - Issue 11414299: Add content/browser/loader/ for resource loading related classes.

Side by Side Diff: content/browser/renderer_host/throttling_resource_handler.cc

Issue 11414299: Add content/browser/loader/ for resource loading related classes. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/

Patch Set: Created 8 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

« content/browser/renderer_host/socket_stream_dispatcher_host.h ('K') | « content/browser/renderer_host/throttling_resource_handler.h ('k') | content/browser/renderer_host/transfer_navigation_resource_throttle.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "content/browser/renderer_host/throttling_resource_handler.h"

6

7 #include "content/public/browser/resource_throttle.h"

8 #include "content/public/common/resource_response.h"

9

10 namespace content {

11

12 ThrottlingResourceHandler::ThrottlingResourceHandler(

13 scoped_ptr<ResourceHandler> next_handler,

14 int child_id,

15 int request_id,

16 ScopedVector<ResourceThrottle> throttles)

17 : LayeredResourceHandler(next_handler.Pass()),

18 deferred_stage_(DEFERRED_NONE),

19 request_id_(request_id),

20 throttles_(throttles.Pass()),

21 index_(0),

22 cancelled_by_resource_throttle_(false) {

23 for (size_t i = 0; i < throttles_.size(); ++i)

24 throttles_[i]->set_controller(this);

25 }

26

27 ThrottlingResourceHandler::~ThrottlingResourceHandler() {

28 }

29

30 bool ThrottlingResourceHandler::OnRequestRedirected(int request_id,

31 const GURL& new_url,

32 ResourceResponse* response,

33 bool* defer) {

34 DCHECK_EQ(request_id_, request_id);

35 DCHECK(!cancelled_by_resource_throttle_);

36

37 *defer = false;

38 while (index_ < throttles_.size()) {

39 throttles_[index_]->WillRedirectRequest(new_url, defer);

40 index_++;

41 if (cancelled_by_resource_throttle_)

42 return false;

43 if (*defer) {

44 deferred_stage_ = DEFERRED_REDIRECT;

45 deferred_url_ = new_url;

46 deferred_response_ = response;

47 return true; // Do not cancel.

48 }

49 }

50

51 index_ = 0; // Reset for next time.

52

53 return next_handler_->OnRequestRedirected(request_id, new_url, response,

54 defer);

55 }

56

57 bool ThrottlingResourceHandler::OnWillStart(int request_id,

58 const GURL& url,

59 bool* defer) {

60 DCHECK_EQ(request_id_, request_id);

61 DCHECK(!cancelled_by_resource_throttle_);

62

63 *defer = false;

64 while (index_ < throttles_.size()) {

65 throttles_[index_]->WillStartRequest(defer);

66 index_++;

67 if (cancelled_by_resource_throttle_)

68 return false;

69 if (*defer) {

70 deferred_stage_ = DEFERRED_START;

71 deferred_url_ = url;

72 return true; // Do not cancel.

73 }

74 }

75

76 index_ = 0; // Reset for next time.

77

78 return next_handler_->OnWillStart(request_id, url, defer);

79 }

80

81 bool ThrottlingResourceHandler::OnResponseStarted(int request_id,

82 ResourceResponse* response,

83 bool* defer) {

84 DCHECK_EQ(request_id_, request_id);

85 DCHECK(!cancelled_by_resource_throttle_);

86

87 while (index_ < throttles_.size()) {

88 throttles_[index_]->WillProcessResponse(defer);

89 index_++;

90 if (cancelled_by_resource_throttle_)

91 return false;

92 if (*defer) {

93 deferred_stage_ = DEFERRED_RESPONSE;

94 deferred_response_ = response;

95 return true; // Do not cancel.

96 }

97 }

98

99 index_ = 0; // Reset for next time.

100

101 return next_handler_->OnResponseStarted(request_id, response, defer);

102 }

103

104 void ThrottlingResourceHandler::Cancel() {

105 cancelled_by_resource_throttle_ = true;

106 controller()->Cancel();

107 }

108

109 void ThrottlingResourceHandler::CancelAndIgnore() {

110 cancelled_by_resource_throttle_ = true;

111 controller()->CancelAndIgnore();

112 }

113

114 void ThrottlingResourceHandler::CancelWithError(int error_code) {

115 cancelled_by_resource_throttle_ = true;

116 controller()->CancelWithError(error_code);

117 }

118

119 void ThrottlingResourceHandler::Resume() {

120 DCHECK(!cancelled_by_resource_throttle_);

121

122 DeferredStage last_deferred_stage = deferred_stage_;

123 deferred_stage_ = DEFERRED_NONE;

124 switch (last_deferred_stage) {

125 case DEFERRED_NONE:

126 NOTREACHED();

127 break;

128 case DEFERRED_START:

129 ResumeStart();

130 break;

131 case DEFERRED_REDIRECT:

132 ResumeRedirect();

133 break;

134 case DEFERRED_RESPONSE:

135 ResumeResponse();

136 break;

137 }

138 }

139

140 void ThrottlingResourceHandler::ResumeStart() {

141 DCHECK(!cancelled_by_resource_throttle_);

142

143 GURL url = deferred_url_;

144 deferred_url_ = GURL();

145

146 bool defer = false;

147 if (!OnWillStart(request_id_, url, &defer)) {

148 controller()->Cancel();

149 } else if (!defer) {

150 controller()->Resume();

151 }

152 }

153

154 void ThrottlingResourceHandler::ResumeRedirect() {

155 DCHECK(!cancelled_by_resource_throttle_);

156

157 GURL new_url = deferred_url_;

158 deferred_url_ = GURL();

159 scoped_refptr<ResourceResponse> response;

160 deferred_response_.swap(response);

161

162 bool defer = false;

163 if (!OnRequestRedirected(request_id_, new_url, response, &defer)) {

164 controller()->Cancel();

165 } else if (!defer) {

166 controller()->Resume();

167 }

168 }

169

170 void ThrottlingResourceHandler::ResumeResponse() {

171 DCHECK(!cancelled_by_resource_throttle_);

172

173 scoped_refptr<ResourceResponse> response;

174 deferred_response_.swap(response);

175

176 bool defer = false;

177 if (!OnResponseStarted(request_id_, response, &defer)) {

178 controller()->Cancel();

179 } else if (!defer) {

180 controller()->Resume();

181 }

182 }

183

184 } // namespace content

OLD	NEW