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
|
// Copyright (c) 2006-2008 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.
#include "config.h"
#include "webkit/glue/resource_fetcher.h"
#include "base/compiler_specific.h"
MSVC_PUSH_WARNING_LEVEL(0);
#include "FrameLoader.h"
#include "ResourceHandle.h"
#include "ResourceRequest.h"
MSVC_POP_WARNING();
#undef LOG
#include "base/logging.h"
#include "webkit/glue/glue_util.h"
#include "net/url_request/url_request_status.h"
using WebCore::ResourceError;
using WebCore::ResourceHandle;
using WebCore::ResourceResponse;
ResourceFetcher::ResourceFetcher(const GURL& url, WebCore::Frame* frame,
Delegate* d)
: url_(url), delegate_(d), completed_(false) {
// Can't do anything without a frame. However, delegate can be NULL (so we
// can do a http request and ignore the results).
DCHECK(frame);
Start(frame);
}
ResourceFetcher::~ResourceFetcher() {
if (!completed_)
loader_->cancel();
loader_ = NULL;
}
void ResourceFetcher::Cancel() {
if (!completed_) {
loader_->cancel();
completed_ = true;
}
}
void ResourceFetcher::Start(WebCore::Frame* frame) {
WebCore::FrameLoader* frame_loader = frame->loader();
if (!frame_loader) {
// We put this on a 0 timer so the callback happens async (consistent with
// regular fetches).
start_failed_timer_.reset(new StartFailedTimer(this,
&ResourceFetcher::StartFailed));
start_failed_timer_->startOneShot(0);
return;
}
WebCore::ResourceRequest request(webkit_glue::GURLToKURL(url_));
request.setFrame(frame);
loader_ = ResourceHandle::create(request, this, NULL, false, false);
}
void ResourceFetcher::StartFailed(StartFailedTimer* timer) {
didFail(NULL, ResourceError());
}
/////////////////////////////////////////////////////////////////////////////
// ResourceHandleClient methods
void ResourceFetcher::didReceiveResponse(ResourceHandle* resource_handle,
const ResourceResponse& response) {
ASSERT(!completed_);
// It's safe to use the ResourceResponse copy constructor
// (xmlhttprequest.cpp uses it).
response_ = response;
}
void ResourceFetcher::didReceiveData(ResourceHandle* resource_handle,
const char* data, int length,
int total_length) {
ASSERT(!completed_);
if (length <= 0)
return;
data_.append(data, length);
}
void ResourceFetcher::didFinishLoading(ResourceHandle* resource_handle) {
ASSERT(!completed_);
completed_ = true;
if (delegate_)
delegate_->OnURLFetchComplete(response_, data_);
}
void ResourceFetcher::didFail(ResourceHandle* resource_handle,
const ResourceError& error) {
ASSERT(!completed_);
completed_ = true;
// Go ahead and tell our delegate that we're done. Send an empty
// ResourceResponse and string.
if (delegate_)
delegate_->OnURLFetchComplete(ResourceResponse(), std::string());
}
/////////////////////////////////////////////////////////////////////////////
// A resource fetcher with a timeout
ResourceFetcherWithTimeout::ResourceFetcherWithTimeout(
const GURL& url, WebCore::Frame* frame, double timeout_secs, Delegate* d)
: ResourceFetcher(url, frame, d) {
timeout_timer_.reset(new FetchTimer(this,
&ResourceFetcherWithTimeout::TimeoutFired));
timeout_timer_->startOneShot(timeout_secs);
}
void ResourceFetcherWithTimeout::TimeoutFired(FetchTimer* timer) {
if (!completed_) {
loader_->cancel();
didFail(NULL, ResourceError());
}
}
|
