summaryrefslogtreecommitdiffstats
path: root/content/renderer
diff options
context:
space:
mode:
Diffstat (limited to 'content/renderer')
-rw-r--r--content/renderer/fetchers/alt_error_page_resource_fetcher.cc56
-rw-r--r--content/renderer/fetchers/alt_error_page_resource_fetcher.h68
-rw-r--r--content/renderer/fetchers/image_resource_fetcher.cc66
-rw-r--r--content/renderer/fetchers/image_resource_fetcher.h65
-rw-r--r--content/renderer/fetchers/multi_resolution_image_resource_fetcher.cc58
-rw-r--r--content/renderer/fetchers/multi_resolution_image_resource_fetcher.h61
-rw-r--r--content/renderer/fetchers/resource_fetcher.cc145
-rw-r--r--content/renderer/fetchers/resource_fetcher.h135
-rw-r--r--content/renderer/image_loading_helper.cc3
-rw-r--r--content/renderer/image_loading_helper.h10
-rw-r--r--content/renderer/internal_document_state_data.cc4
-rw-r--r--content/renderer/internal_document_state_data.h11
-rw-r--r--content/renderer/render_view_impl.cc8
-rw-r--r--content/renderer/render_view_impl.h10
-rw-r--r--content/renderer/resource_fetcher_browsertest.cc4
15 files changed, 672 insertions, 32 deletions
diff --git a/content/renderer/fetchers/alt_error_page_resource_fetcher.cc b/content/renderer/fetchers/alt_error_page_resource_fetcher.cc
new file mode 100644
index 0000000..cbcab09
--- /dev/null
+++ b/content/renderer/fetchers/alt_error_page_resource_fetcher.cc
@@ -0,0 +1,56 @@
+// Copyright (c) 2011 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 "content/renderer/fetchers/alt_error_page_resource_fetcher.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "content/renderer/fetchers/resource_fetcher.h"
+
+using WebKit::WebFrame;
+using WebKit::WebURLError;
+using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
+
+namespace content {
+
+// Number of seconds to wait for the alternate error page server. If it takes
+// too long, just use the local error page.
+static const int kDownloadTimeoutSec = 3;
+
+AltErrorPageResourceFetcher::AltErrorPageResourceFetcher(
+ const GURL& url,
+ WebFrame* frame,
+ const WebURLRequest& original_request,
+ const WebURLError& original_error,
+ const Callback& callback)
+ : frame_(frame),
+ callback_(callback),
+ original_request_(original_request),
+ original_error_(original_error) {
+ fetcher_.reset(new ResourceFetcherWithTimeout(
+ url, frame, WebURLRequest::TargetIsMainFrame, kDownloadTimeoutSec,
+ base::Bind(&AltErrorPageResourceFetcher::OnURLFetchComplete,
+ base::Unretained(this))));
+}
+
+AltErrorPageResourceFetcher::~AltErrorPageResourceFetcher() {
+}
+
+void AltErrorPageResourceFetcher::Cancel() {
+ fetcher_->Cancel();
+}
+
+void AltErrorPageResourceFetcher::OnURLFetchComplete(
+ const WebURLResponse& response,
+ const std::string& data) {
+ // A null response indicates a network error.
+ if (!response.isNull() && response.httpStatusCode() == 200) {
+ callback_.Run(frame_, original_request_, original_error_, data);
+ } else {
+ callback_.Run(frame_, original_request_, original_error_, std::string());
+ }
+}
+
+} // namespace content
diff --git a/content/renderer/fetchers/alt_error_page_resource_fetcher.h b/content/renderer/fetchers/alt_error_page_resource_fetcher.h
new file mode 100644
index 0000000..14ffd7d
--- /dev/null
+++ b/content/renderer/fetchers/alt_error_page_resource_fetcher.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2011 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.
+
+#ifndef CONTENT_RENDERER_FETCHERS_ALT_ERROR_PAGE_RESOURCE_FETCHER_H_
+#define CONTENT_RENDERER_FETCHERS_ALT_ERROR_PAGE_RESOURCE_FETCHER_H_
+
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "googleurl/src/gurl.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLError.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
+
+namespace WebKit {
+class WebFrame;
+class WebURLResponse;
+}
+
+namespace content {
+class ResourceFetcherWithTimeout;
+
+// Used for downloading alternate dns error pages. Once downloading is done
+// (or fails), the webview delegate is notified.
+class AltErrorPageResourceFetcher {
+ public:
+ // This will be called when the alternative error page has been fetched,
+ // successfully or not. If there is a failure, the third parameter (the
+ // data) will be empty.
+ typedef base::Callback<void(WebKit::WebFrame*,
+ const WebKit::WebURLRequest&,
+ const WebKit::WebURLError&,
+ const std::string&)> Callback;
+
+ AltErrorPageResourceFetcher(
+ const GURL& url,
+ WebKit::WebFrame* frame,
+ const WebKit::WebURLRequest& original_request,
+ const WebKit::WebURLError& original_error,
+ const Callback& callback);
+ ~AltErrorPageResourceFetcher();
+
+ // Stop any pending loads.
+ void Cancel();
+
+ private:
+ void OnURLFetchComplete(const WebKit::WebURLResponse& response,
+ const std::string& data);
+
+ // Does the actual fetching.
+ scoped_ptr<ResourceFetcherWithTimeout> fetcher_;
+
+ WebKit::WebFrame* frame_;
+ Callback callback_;
+
+ // The original request. If loading the alternate error page fails, it's
+ // needed to generate the error page.
+ WebKit::WebURLRequest original_request_;
+
+ // The error associated with this load. If there's an error talking with the
+ // alt error page server, we need this to complete the original load.
+ WebKit::WebURLError original_error_;
+
+ DISALLOW_COPY_AND_ASSIGN(AltErrorPageResourceFetcher);
+};
+
+} // namespace content
+
+#endif // CONTENT_RENDERER_FETCHERS_ALT_ERROR_PAGE_RESOURCE_FETCHER_H_
diff --git a/content/renderer/fetchers/image_resource_fetcher.cc b/content/renderer/fetchers/image_resource_fetcher.cc
new file mode 100644
index 0000000..8185e61
--- /dev/null
+++ b/content/renderer/fetchers/image_resource_fetcher.cc
@@ -0,0 +1,66 @@
+// Copyright (c) 2011 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 "content/renderer/fetchers/image_resource_fetcher.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/debug/crash_logging.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/size.h"
+#include "webkit/glue/image_decoder.h"
+
+using WebKit::WebFrame;
+using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
+
+namespace content {
+
+ImageResourceFetcher::ImageResourceFetcher(
+ const GURL& image_url,
+ WebFrame* frame,
+ int id,
+ int image_size,
+ WebURLRequest::TargetType target_type,
+ const Callback& callback)
+ : callback_(callback),
+ id_(id),
+ image_url_(image_url),
+ image_size_(image_size) {
+ fetcher_.reset(new ResourceFetcher(
+ image_url, frame, target_type,
+ base::Bind(&ImageResourceFetcher::OnURLFetchComplete,
+ base::Unretained(this))));
+
+ // Set subresource URL for crash reporting.
+ base::debug::SetCrashKeyValue("subresource_url", image_url.spec());
+}
+
+ImageResourceFetcher::~ImageResourceFetcher() {
+ if (!fetcher_->completed())
+ fetcher_->Cancel();
+}
+
+void ImageResourceFetcher::OnURLFetchComplete(
+ const WebURLResponse& response,
+ const std::string& data) {
+ SkBitmap bitmap;
+ if (!response.isNull() && response.httpStatusCode() == 200) {
+ // Request succeeded, try to convert it to an image.
+ webkit_glue::ImageDecoder decoder(gfx::Size(image_size_, image_size_));
+ bitmap = decoder.Decode(
+ reinterpret_cast<const unsigned char*>(data.data()), data.size());
+ } // else case:
+ // If we get here, it means no image from server or couldn't decode the
+ // response as an image. The delegate will see a null image, indicating
+ // that an error occurred.
+
+ // Take a reference to the callback as running the callback may lead to our
+ // destruction.
+ Callback callback = callback_;
+ callback.Run(this, bitmap);
+}
+
+} // namespace content
diff --git a/content/renderer/fetchers/image_resource_fetcher.h b/content/renderer/fetchers/image_resource_fetcher.h
new file mode 100644
index 0000000..2ddb20d
--- /dev/null
+++ b/content/renderer/fetchers/image_resource_fetcher.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2011 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.
+
+#ifndef CONTENT_RENDERER_FETCHERS_IMAGE_RESOURCE_FETCHER_H_
+#define CONTENT_RENDERER_FETCHERS_IMAGE_RESOURCE_FETCHER_H_
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "content/renderer/fetchers/resource_fetcher.h"
+
+class SkBitmap;
+
+namespace content {
+
+// ImageResourceFetcher handles downloading an image for a webview. Once
+// downloading is done the supplied callback is notified. ImageResourceFetcher
+// is used to download the favicon and images for web apps.
+class ImageResourceFetcher {
+ public:
+ typedef base::Callback<void(ImageResourceFetcher*, const SkBitmap&)> Callback;
+
+ ImageResourceFetcher(
+ const GURL& image_url,
+ WebKit::WebFrame* frame,
+ int id,
+ int image_size,
+ WebKit::WebURLRequest::TargetType target_type,
+ const Callback& callback);
+
+ virtual ~ImageResourceFetcher();
+
+ // URL of the image we're downloading.
+ const GURL& image_url() const { return image_url_; }
+
+ // Unique identifier for the request.
+ int id() const { return id_; }
+
+ private:
+ // ResourceFetcher::Callback. Decodes the image and invokes callback_.
+ void OnURLFetchComplete(const WebKit::WebURLResponse& response,
+ const std::string& data);
+
+ Callback callback_;
+
+ // Unique identifier for the request.
+ const int id_;
+
+ // URL of the image.
+ const GURL image_url_;
+
+ // The size of the image. This is only a hint that is used if the image
+ // contains multiple sizes. A value of 0 results in using the first frame
+ // of the image.
+ const int image_size_;
+
+ // Does the actual download.
+ scoped_ptr<ResourceFetcher> fetcher_;
+
+ DISALLOW_COPY_AND_ASSIGN(ImageResourceFetcher);
+};
+
+} // namespace content
+
+#endif // CONTENT_RENDERER_FETCHERS_IMAGE_RESOURCE_FETCHER_H_
diff --git a/content/renderer/fetchers/multi_resolution_image_resource_fetcher.cc b/content/renderer/fetchers/multi_resolution_image_resource_fetcher.cc
new file mode 100644
index 0000000..33235c1
--- /dev/null
+++ b/content/renderer/fetchers/multi_resolution_image_resource_fetcher.cc
@@ -0,0 +1,58 @@
+// 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.
+
+#include "content/renderer/fetchers/multi_resolution_image_resource_fetcher.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/size.h"
+#include "webkit/glue/image_decoder.h"
+
+using WebKit::WebFrame;
+using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
+
+namespace content {
+
+MultiResolutionImageResourceFetcher::MultiResolutionImageResourceFetcher(
+ const GURL& image_url,
+ WebFrame* frame,
+ int id,
+ WebURLRequest::TargetType target_type,
+ const Callback& callback)
+ : callback_(callback),
+ id_(id),
+ image_url_(image_url) {
+ fetcher_.reset(new ResourceFetcher(
+ image_url, frame, target_type,
+ base::Bind(&MultiResolutionImageResourceFetcher::OnURLFetchComplete,
+ base::Unretained(this))));
+}
+
+MultiResolutionImageResourceFetcher::~MultiResolutionImageResourceFetcher() {
+ if (!fetcher_->completed())
+ fetcher_->Cancel();
+}
+
+void MultiResolutionImageResourceFetcher::OnURLFetchComplete(
+ const WebURLResponse& response,
+ const std::string& data) {
+ std::vector<SkBitmap> bitmaps;
+ if (!response.isNull() && response.httpStatusCode() == 200) {
+ // Request succeeded, try to convert it to an image.
+ bitmaps = webkit_glue::ImageDecoder::DecodeAll(
+ reinterpret_cast<const unsigned char*>(data.data()), data.size());
+ } // else case:
+ // If we get here, it means no image from server or couldn't decode the
+ // response as an image. The delegate will see an empty vector.
+
+ // Take a reference to the callback as running the callback may lead to our
+ // destruction.
+ Callback callback = callback_;
+ callback.Run(this, bitmaps);
+}
+
+} // namespace content
diff --git a/content/renderer/fetchers/multi_resolution_image_resource_fetcher.h b/content/renderer/fetchers/multi_resolution_image_resource_fetcher.h
new file mode 100644
index 0000000..925eed2
--- /dev/null
+++ b/content/renderer/fetchers/multi_resolution_image_resource_fetcher.h
@@ -0,0 +1,61 @@
+// 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.
+
+#ifndef CONTENT_RENDERER_FETCHERS_MULTI_RESOLUTION_IMAGE_RESOURCE_FETCHER_H_
+#define CONTENT_RENDERER_FETCHERS_MULTI_RESOLUTION_IMAGE_RESOURCE_FETCHER_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "content/renderer/fetchers/resource_fetcher.h"
+
+class SkBitmap;
+
+namespace content {
+
+// A resource fetcher that returns all (differently-sized) frames in
+// an image. Useful for favicons.
+class MultiResolutionImageResourceFetcher{
+ public:
+ typedef base::Callback<void(MultiResolutionImageResourceFetcher*,
+ const std::vector<SkBitmap>&)> Callback;
+
+ MultiResolutionImageResourceFetcher(
+ const GURL& image_url,
+ WebKit::WebFrame* frame,
+ int id,
+ WebKit::WebURLRequest::TargetType target_type,
+ const Callback& callback);
+
+ virtual ~MultiResolutionImageResourceFetcher();
+
+ // URL of the image we're downloading.
+ const GURL& image_url() const { return image_url_; }
+
+ // Unique identifier for the request.
+ int id() const { return id_; }
+
+ private:
+ // ResourceFetcher::Callback. Decodes the image and invokes callback_.
+ void OnURLFetchComplete(const WebKit::WebURLResponse& response,
+ const std::string& data);
+
+ Callback callback_;
+
+ // Unique identifier for the request.
+ const int id_;
+
+ // URL of the image.
+ const GURL image_url_;
+
+ // Does the actual download.
+ scoped_ptr<ResourceFetcher> fetcher_;
+
+ DISALLOW_COPY_AND_ASSIGN(MultiResolutionImageResourceFetcher);
+};
+
+} // namespace content
+
+#endif // CONTENT_RENDERER_FETCHERS_MULTI_RESOLUTION_IMAGE_RESOURCE_FETCHER_H_
diff --git a/content/renderer/fetchers/resource_fetcher.cc b/content/renderer/fetchers/resource_fetcher.cc
new file mode 100644
index 0000000..bbb7959
--- /dev/null
+++ b/content/renderer/fetchers/resource_fetcher.cc
@@ -0,0 +1,145 @@
+// 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.
+
+#include "content/renderer/fetchers/resource_fetcher.h"
+
+#include "base/logging.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLError.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLLoader.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
+
+using base::TimeDelta;
+using WebKit::WebFrame;
+using WebKit::WebURLError;
+using WebKit::WebURLLoader;
+using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
+
+namespace content {
+
+ResourceFetcher::ResourceFetcher(const GURL& url, WebFrame* frame,
+ WebURLRequest::TargetType target_type,
+ const Callback& callback)
+ : url_(url),
+ target_type_(target_type),
+ completed_(false),
+ callback_(callback) {
+ // 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_)
+ loader_->cancel();
+}
+
+void ResourceFetcher::Cancel() {
+ if (!completed_) {
+ loader_->cancel();
+ completed_ = true;
+ }
+}
+
+void ResourceFetcher::Start(WebFrame* frame) {
+ WebURLRequest request(url_);
+ request.setTargetType(target_type_);
+ request.setFirstPartyForCookies(frame->document().firstPartyForCookies());
+ frame->dispatchWillSendRequest(request);
+
+ loader_.reset(WebKit::Platform::current()->createURLLoader());
+ loader_->loadAsynchronously(request, this);
+}
+
+void ResourceFetcher::RunCallback(const WebURLResponse& response,
+ const std::string& data) {
+ if (callback_.is_null())
+ return;
+
+ // Take a reference to the callback as running the callback may lead to our
+ // destruction.
+ Callback callback = callback_;
+ callback.Run(response, data);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// WebURLLoaderClient methods
+
+void ResourceFetcher::willSendRequest(
+ WebURLLoader* loader, WebURLRequest& new_request,
+ const WebURLResponse& redirect_response) {
+}
+
+void ResourceFetcher::didSendData(
+ WebURLLoader* loader, unsigned long long bytes_sent,
+ unsigned long long total_bytes_to_be_sent) {
+}
+
+void ResourceFetcher::didReceiveResponse(
+ WebURLLoader* loader, const WebURLResponse& response) {
+ DCHECK(!completed_);
+ response_ = response;
+}
+
+void ResourceFetcher::didReceiveData(
+ WebURLLoader* loader, const char* data, int data_length,
+ int encoded_data_length) {
+ DCHECK(!completed_);
+ DCHECK(data_length > 0);
+
+ data_.append(data, data_length);
+}
+
+void ResourceFetcher::didReceiveCachedMetadata(
+ WebURLLoader* loader, const char* data, int data_length) {
+ DCHECK(!completed_);
+ DCHECK(data_length > 0);
+
+ metadata_.assign(data, data_length);
+}
+
+void ResourceFetcher::didFinishLoading(
+ WebURLLoader* loader, double finishTime) {
+ DCHECK(!completed_);
+ completed_ = true;
+
+ RunCallback(response_, data_);
+}
+
+void ResourceFetcher::didFail(WebURLLoader* loader, const WebURLError& error) {
+ DCHECK(!completed_);
+ completed_ = true;
+
+ // Go ahead and tell our delegate that we're done.
+ RunCallback(WebURLResponse(), std::string());
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// A resource fetcher with a timeout
+
+ResourceFetcherWithTimeout::ResourceFetcherWithTimeout(
+ const GURL& url, WebFrame* frame, WebURLRequest::TargetType target_type,
+ int timeout_secs, const Callback& callback)
+ : ResourceFetcher(url, frame, target_type, callback) {
+ timeout_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(timeout_secs), this,
+ &ResourceFetcherWithTimeout::TimeoutFired);
+}
+
+ResourceFetcherWithTimeout::~ResourceFetcherWithTimeout() {
+}
+
+void ResourceFetcherWithTimeout::TimeoutFired() {
+ if (!completed_) {
+ loader_->cancel();
+ didFail(NULL, WebURLError());
+ }
+}
+
+} // namespace content
diff --git a/content/renderer/fetchers/resource_fetcher.h b/content/renderer/fetchers/resource_fetcher.h
new file mode 100644
index 0000000..1580d20
--- /dev/null
+++ b/content/renderer/fetchers/resource_fetcher.h
@@ -0,0 +1,135 @@
+// Copyright (c) 2011 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.
+//
+// A wrapper around ResourceHandle and ResourceHandleClient that simplifies
+// the download of an HTTP object. The interface is modeled after URLFetcher
+// in the /chrome/browser.
+//
+// ResourceFetcher::Delegate::OnURLFetchComplete will be called async after
+// the ResourceFetcher object is created.
+
+#ifndef CONTENT_RENDERER_FETCHERS_RESOURCE_FETCHER_H_
+#define CONTENT_RENDERER_FETCHERS_RESOURCE_FETCHER_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/timer.h"
+#include "content/common/content_export.h"
+#include "googleurl/src/gurl.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLLoaderClient.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebURLResponse.h"
+
+class GURL;
+
+namespace WebKit {
+class WebFrame;
+class WebURLLoader;
+struct WebURLError;
+}
+
+namespace content {
+
+class CONTENT_EXPORT ResourceFetcher
+ : NON_EXPORTED_BASE(public WebKit::WebURLLoaderClient) {
+ public:
+ // This will be called when the URL has been fetched, successfully or not.
+ // If there is a failure, response and data will both be empty. |response|
+ // and |data| are both valid until the URLFetcher instance is destroyed.
+ typedef base::Callback<void(const WebKit::WebURLResponse&,
+ const std::string&)> Callback;
+
+ // We need a frame to make requests.
+ ResourceFetcher(
+ const GURL& url, WebKit::WebFrame* frame,
+ WebKit::WebURLRequest::TargetType target_type,
+ const Callback& callback);
+ virtual ~ResourceFetcher();
+
+ // Stop the request and don't call the callback.
+ void Cancel();
+
+ bool completed() const { return completed_; }
+
+ protected:
+ // WebURLLoaderClient methods:
+ virtual void willSendRequest(
+ WebKit::WebURLLoader* loader, WebKit::WebURLRequest& new_request,
+ const WebKit::WebURLResponse& redirect_response);
+ virtual void didSendData(
+ WebKit::WebURLLoader* loader, unsigned long long bytes_sent,
+ unsigned long long total_bytes_to_be_sent);
+ virtual void didReceiveResponse(
+ WebKit::WebURLLoader* loader, const WebKit::WebURLResponse& response);
+ virtual void didReceiveCachedMetadata(
+ WebKit::WebURLLoader* loader, const char* data, int data_length);
+
+ virtual void didReceiveData(
+ WebKit::WebURLLoader* loader, const char* data, int data_length,
+ int encoded_data_length);
+ virtual void didFinishLoading(
+ WebKit::WebURLLoader* loader, double finishTime);
+ virtual void didFail(
+ WebKit::WebURLLoader* loader, const WebKit::WebURLError& error);
+
+ scoped_ptr<WebKit::WebURLLoader> loader_;
+
+ // URL we're fetching
+ GURL url_;
+
+ // Target type
+ WebKit::WebURLRequest::TargetType target_type_;
+
+ // A copy of the original resource response
+ WebKit::WebURLResponse response_;
+
+ // Set to true once the request is compelte.
+ bool completed_;
+
+ private:
+ // Start the actual download.
+ void Start(WebKit::WebFrame* frame);
+
+ void RunCallback(const WebKit::WebURLResponse& response,
+ const std::string& data);
+
+ // Callback when we're done
+ Callback callback_;
+
+ // Buffer to hold the content from the server.
+ std::string data_;
+
+ // Buffer to hold metadata from the cache.
+ std::string metadata_;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// A resource fetcher with a timeout
+class CONTENT_EXPORT ResourceFetcherWithTimeout
+ : NON_EXPORTED_BASE(public ResourceFetcher) {
+ public:
+ ResourceFetcherWithTimeout(const GURL& url,
+ WebKit::WebFrame* frame,
+ WebKit::WebURLRequest::TargetType target_type,
+ int timeout_secs,
+ const Callback& callback);
+ virtual ~ResourceFetcherWithTimeout();
+
+ private:
+ // Callback for timer that limits how long we wait for the alternate error
+ // page server. If this timer fires and the request hasn't completed, we
+ // kill the request.
+ void TimeoutFired();
+
+ // Limit how long we wait for the alternate error page server.
+ base::OneShotTimer<ResourceFetcherWithTimeout> timeout_timer_;
+};
+
+} // namespace content
+
+#endif // CONTENT_RENDERER_FETCHERS_RESOURCE_FETCHER_H_
diff --git a/content/renderer/image_loading_helper.cc b/content/renderer/image_loading_helper.cc
index ff6e2bd..5f936a41f3 100644
--- a/content/renderer/image_loading_helper.cc
+++ b/content/renderer/image_loading_helper.cc
@@ -9,6 +9,7 @@
#include "content/common/image_messages.h"
#include "content/public/common/url_constants.h"
#include "content/public/renderer/render_view.h"
+#include "content/renderer/fetchers/multi_resolution_image_resource_fetcher.h"
#include "net/base/data_url.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebVector.h"
@@ -18,14 +19,12 @@
#include "ui/gfx/size.h"
#include "ui/gfx/skbitmap_operations.h"
#include "webkit/glue/image_decoder.h"
-#include "webkit/glue/multi_resolution_image_resource_fetcher.h"
#include "webkit/glue/webkit_glue.h"
using WebKit::WebFrame;
using WebKit::WebVector;
using WebKit::WebURL;
using WebKit::WebURLRequest;
-using webkit_glue::MultiResolutionImageResourceFetcher;
namespace content {
diff --git a/content/renderer/image_loading_helper.h b/content/renderer/image_loading_helper.h
index 6e2302d..6856aa3 100644
--- a/content/renderer/image_loading_helper.h
+++ b/content/renderer/image_loading_helper.h
@@ -14,12 +14,10 @@
class SkBitmap;
-namespace webkit_glue {
-class MultiResolutionImageResourceFetcher;
-}
-
namespace content {
+class MultiResolutionImageResourceFetcher;
+
// This class deals with image downloading.
// One instance of ImageLoadingHelper is owned by RenderView.
class ImageLoadingHelper : public RenderViewObserver {
@@ -53,7 +51,7 @@ class ImageLoadingHelper : public RenderViewObserver {
// details.
void DidDownloadImage(
int requested_size,
- webkit_glue::MultiResolutionImageResourceFetcher* fetcher,
+ MultiResolutionImageResourceFetcher* fetcher,
const std::vector<SkBitmap>& images);
// Decodes a data: URL image or returns an empty image in case of failure.
@@ -62,7 +60,7 @@ class ImageLoadingHelper : public RenderViewObserver {
// RenderViewObserver implementation.
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
- typedef ScopedVector<webkit_glue::MultiResolutionImageResourceFetcher>
+ typedef ScopedVector<MultiResolutionImageResourceFetcher>
ImageResourceFetcherList;
// ImageResourceFetchers schedule via DownloadImage.
diff --git a/content/renderer/internal_document_state_data.cc b/content/renderer/internal_document_state_data.cc
index d5da984..b63410a 100644
--- a/content/renderer/internal_document_state_data.cc
+++ b/content/renderer/internal_document_state_data.cc
@@ -6,8 +6,8 @@
#include "content/public/common/password_form.h"
#include "content/public/renderer/document_state.h"
+#include "content/renderer/fetchers/alt_error_page_resource_fetcher.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
-#include "webkit/glue/alt_error_page_resource_fetcher.h"
namespace content {
@@ -55,7 +55,7 @@ InternalDocumentStateData::~InternalDocumentStateData() {
}
void InternalDocumentStateData::set_alt_error_page_fetcher(
- webkit_glue::AltErrorPageResourceFetcher* f) {
+ AltErrorPageResourceFetcher* f) {
alt_error_page_fetcher_.reset(f);
}
diff --git a/content/renderer/internal_document_state_data.h b/content/renderer/internal_document_state_data.h
index 08ca357..223e9ad 100644
--- a/content/renderer/internal_document_state_data.h
+++ b/content/renderer/internal_document_state_data.h
@@ -13,16 +13,13 @@
#include "third_party/WebKit/Source/Platform/chromium/public/WebReferrerPolicy.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
-namespace webkit_glue {
-class AltErrorPageResourceFetcher;
-}
-
namespace WebKit {
class WebDataSource;
}
namespace content {
+class AltErrorPageResourceFetcher;
class DocumentState;
// Stores internal state per WebDataSource.
@@ -123,10 +120,10 @@ class InternalDocumentStateData : public base::SupportsUserData::Data {
}
bool is_referrer_policy_set() const { return referrer_policy_set_; }
- webkit_glue::AltErrorPageResourceFetcher* alt_error_page_fetcher() const {
+ AltErrorPageResourceFetcher* alt_error_page_fetcher() const {
return alt_error_page_fetcher_.get();
}
- void set_alt_error_page_fetcher(webkit_glue::AltErrorPageResourceFetcher* f);
+ void set_alt_error_page_fetcher(AltErrorPageResourceFetcher* f);
protected:
virtual ~InternalDocumentStateData();
@@ -144,7 +141,7 @@ class InternalDocumentStateData : public base::SupportsUserData::Data {
WebKit::WebURLRequest::CachePolicy cache_policy_override_;
bool referrer_policy_set_;
WebKit::WebReferrerPolicy referrer_policy_;
- scoped_ptr<webkit_glue::AltErrorPageResourceFetcher> alt_error_page_fetcher_;
+ scoped_ptr<AltErrorPageResourceFetcher> alt_error_page_fetcher_;
DISALLOW_COPY_AND_ASSIGN(InternalDocumentStateData);
};
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index a189b7b..5aa6276 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -74,6 +74,7 @@
#include "content/renderer/dom_automation_controller.h"
#include "content/renderer/dom_storage/webstoragenamespace_impl.h"
#include "content/renderer/external_popup_menu.h"
+#include "content/renderer/fetchers/alt_error_page_resource_fetcher.h"
#include "content/renderer/geolocation_dispatcher.h"
#include "content/renderer/gpu/input_handler_manager.h"
#include "content/renderer/gpu/render_widget_compositor.h"
@@ -122,8 +123,6 @@
#include "net/base/net_errors.h"
#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
#include "net/http/http_util.h"
-#include "third_party/skia/include/core/SkBitmap.h"
-#include "third_party/skia/include/core/SkPicture.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebDragData.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebFileSystemType.h"
@@ -182,6 +181,8 @@
#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebWindowFeatures.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/default/WebRenderTheme.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkPicture.h"
#include "ui/base/ui_base_switches_util.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/gfx/point.h"
@@ -193,7 +194,6 @@
#include "webkit/appcache/web_application_cache_host_impl.h"
#include "webkit/base/file_path_string_conversions.h"
#include "webkit/dom_storage/dom_storage_types.h"
-#include "webkit/glue/alt_error_page_resource_fetcher.h"
#include "webkit/glue/dom_operations.h"
#include "webkit/glue/glue_serialize.h"
#include "webkit/glue/webdropdata.h"
@@ -324,8 +324,6 @@ using appcache::WebApplicationCacheHostImpl;
using base::Time;
using base::TimeDelta;
-using webkit_glue::AltErrorPageResourceFetcher;
-using webkit_glue::ResourceFetcher;
using webkit_glue::WebURLResponseExtraDataImpl;
#if defined(OS_ANDROID)
diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
index 466f293..7d7e8f3 100644
--- a/content/renderer/render_view_impl.h
+++ b/content/renderer/render_view_impl.h
@@ -90,11 +90,6 @@ class PluginInstance;
} // namespace webkit
-namespace webkit_glue {
-class ImageResourceFetcher;
-class ResourceFetcher;
-}
-
#if defined(OS_ANDROID)
namespace webkit_media {
class WebMediaPlayerManagerAndroid;
@@ -150,6 +145,7 @@ class DomAutomationController;
class ExternalPopupMenu;
class FaviconHelper;
class GeolocationDispatcher;
+class ImageResourceFetcher;
class InputTagSpeechDispatcher;
class JavaBridgeDispatcher;
class LoadProgressTracker;
@@ -758,7 +754,7 @@ class CONTENT_EXPORT RenderViewImpl
// Cannot use std::set unfortunately since linked_ptr<> does not support
// operator<.
- typedef std::vector<linked_ptr<webkit_glue::ImageResourceFetcher> >
+ typedef std::vector<linked_ptr<ImageResourceFetcher> >
ImageResourceFetcherList;
protected:
@@ -1085,7 +1081,7 @@ class CONTENT_EXPORT RenderViewImpl
// This callback is triggered when DownloadFavicon completes, either
// succesfully or with a failure. See DownloadFavicon for more
// details.
- void DidDownloadFavicon(webkit_glue::ImageResourceFetcher* fetcher,
+ void DidDownloadFavicon(ImageResourceFetcher* fetcher,
const SkBitmap& image);
// Requests to download a favicon image. When done, the RenderView is notified
diff --git a/content/renderer/resource_fetcher_browsertest.cc b/content/renderer/resource_fetcher_browsertest.cc
index e7e0c36..f246a3b 100644
--- a/content/renderer/resource_fetcher_browsertest.cc
+++ b/content/renderer/resource_fetcher_browsertest.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "webkit/glue/resource_fetcher.h"
+#include "content/renderer/fetchers/resource_fetcher.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
@@ -22,8 +22,6 @@
using WebKit::WebFrame;
using WebKit::WebURLRequest;
using WebKit::WebURLResponse;
-using webkit_glue::ResourceFetcher;
-using webkit_glue::ResourceFetcherWithTimeout;
namespace content {
generated by cgit v1.1 at 2025-02-02 07:42:46 +0000