Allow data URLs to trigger downloads, as they do in Firefox....

webkit/glue/weburlloader_impl.cc

 // Copyright (c) 2010 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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/glue/weburlloader_impl.h"
 
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/data_url.h"
 #include "net/base/load_flags.h"
+#include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_response_headers.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebHTTPHeaderVisitor.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebHTTPLoadInfo.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLLoadTiming.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURLLoaderClient.h"
@@ skipping 268 matching lines @@
   virtual void OnReceivedCachedMetadata(const char* data, int len);
   virtual void OnCompletedRequest(
       const URLRequestStatus& status,
       const std::string& security_info,
       const base::Time& completion_time);
 
  private:
   friend class base::RefCounted<Context>;
   ~Context() {}
 
+  // We can optimize the handling of data URLs in most cases.
+  bool CanHandleDataURL(const GURL& url) const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   scoped_ptr<ResourceLoaderBridge> bridge_;
   scoped_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   scoped_ptr<MultipartResponseDelegate> multipart_delegate_;
   scoped_ptr<ResourceLoaderBridge> completed_bridge_;
 
@@ skipping 28 matching lines @@
 }
 
 void WebURLLoaderImpl::Context::Start(
     const WebURLRequest& request,
     ResourceLoaderBridge::SyncLoadResponse* sync_load_response) {
   DCHECK(!bridge_.get());
 
   request_ = request;  // Save the request.
 
   GURL url = request.url();
-  if (url.SchemeIs("data")) {
+  if (url.SchemeIs("data") && CanHandleDataURL(url)) {
     if (sync_load_response) {
       // This is a sync load. Do the work now.
       sync_load_response->url = url;
       std::string data;
       GetInfoFromDataURL(sync_load_response->url, sync_load_response,
                          &sync_load_response->data,
                          &sync_load_response->status);
     } else {
       AddRef();  // Balanced in OnCompletedRequest
       MessageLoop::current()->PostTask(FROM_HERE,
@@ skipping 291 matching lines @@
 
   // Temporary logging, see site_isolation_metrics.h/cc
   SiteIsolationMetrics::RemoveCompletedResponse(response_url_);
 
   // We are done with the bridge now, and so we need to release the reference
   // to ourselves that we took on behalf of the bridge.  This may cause our
   // destruction.
   Release();
 }
 
+bool WebURLLoaderImpl::Context::CanHandleDataURL(const GURL& url) const {
+  DCHECK(url.SchemeIs("data"));
+
+  // Optimize for the case where we can handle a data URL locally.  We must
+  // skip this for data URLs targetted at frames since those could trigger a
+  // download.
+  //
+  // NOTE: We special case MIME types we can render both for performance
+  // reasons as well as to support unit tests, which do not have an underlying
+  // ResourceLoaderBridge implementation.
+
+  if (request_.targetType() != WebURLRequest::TargetIsMainFrame &&
+      request_.targetType() != WebURLRequest::TargetIsSubframe)
+    return true;
+
+  std::string mime_type, unused_charset;
+  if (net::DataURL::Parse(url, &mime_type, &unused_charset, NULL) &&
+      net::IsSupportedMimeType(mime_type))
+    return true;
+
+  return false;
+}
+
 void WebURLLoaderImpl::Context::HandleDataURL() {
   ResourceResponseInfo info;
   URLRequestStatus status;
   std::string data;
 
   if (GetInfoFromDataURL(request_.url(), &info, &data, &status)) {
     OnReceivedResponse(info, false);
     if (!data.empty())
       OnReceivedData(data.data(), data.size());
   }
@@ skipping 48 matching lines @@
 
 void WebURLLoaderImpl::cancel() {
   context_->Cancel();
 }
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 }  // namespace webkit_glue