[WebURLLoaderImpl] Don't respond to data URL request if downloadToFile is set

content/child/web_url_loader_impl.cc

 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 229 matching lines @@
       bool stale_copy_in_cache,
       const std::string& security_info,
       const base::TimeTicks& completion_time,
       int64 total_transfer_size) OVERRIDE;
 
  private:
   friend class base::RefCounted<Context>;
   virtual ~Context() {}
 
   // We can optimize the handling of data URLs in most cases.
-  bool CanHandleDataURL(const GURL& url) const;
+  bool IsHandlableDataURLRequest() const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   ResourceDispatcher* resource_dispatcher_;
   WebReferrerPolicy referrer_policy_;
   scoped_ptr<ResourceLoaderBridge> bridge_;
   scoped_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   scoped_ptr<MultipartResponseDelegate> multipart_delegate_;
@@ skipping 47 matching lines @@
   return false;
 }
 
 void WebURLLoaderImpl::Context::Start(const WebURLRequest& request,
                                       SyncLoadResponse* sync_load_response) {
   DCHECK(!bridge_.get());
 
   request_ = request;  // Save the request.
 
   GURL url = request.url();
-  if (url.SchemeIs("data") && CanHandleDataURL(url)) {
+  if (IsHandlableDataURLRequest()) {

[darin (slow to review), 2014/09/09 05:59:11]

Hmm, "Handleable" is probably a better spelling than "Handlable", but it still
reads fairly awkwardly. How about ShouldHandleDataURLRequest?

[tyoshino (SeeGerritForStatus), 2014/09/09 07:11:59]

Thanks for suggestion.

     if (sync_load_response) {
       // This is a sync load. Do the work now.
       sync_load_response->url = url;
       sync_load_response->error_code =
           GetInfoFromDataURL(sync_load_response->url, sync_load_response,
                              &sync_load_response->data);
     } else {
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&Context::HandleDataURL, this));
     }
@@ skipping 322 matching lines @@
                                             stale_copy_in_cache,
                                             error_code));
     } else {
       client_->didFinishLoading(
           loader_, (completion_time - TimeTicks()).InSecondsF(),
           total_transfer_size);
     }
   }
 }
 
-bool WebURLLoaderImpl::Context::CanHandleDataURL(const GURL& url) const {
-  DCHECK(url.SchemeIs("data"));
+bool WebURLLoaderImpl::Context::IsHandlableDataURLRequest() const {
+  if (!request_.url().SchemeIs("data"))
+    return false;
 
   // 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 defined(OS_ANDROID)
   // For compatibility reasons on Android we need to expose top-level data://
   // to the browser.
   if (request_.frameType() == WebURLRequest::FrameTypeTopLevel)
     return false;
 #endif
 
   if (request_.frameType() != WebURLRequest::FrameTypeTopLevel &&
       request_.frameType() != WebURLRequest::FrameTypeNested)
     return true;
 
   std::string mime_type, unused_charset;
-  if (net::DataURL::Parse(url, &mime_type, &unused_charset, NULL) &&
+  if (net::DataURL::Parse(request_.url(), &mime_type, &unused_charset, NULL) &&
       net::IsSupportedMimeType(mime_type))
     return true;
 
   return false;
 }
 
 void WebURLLoaderImpl::Context::HandleDataURL() {
   ResourceResponseInfo info;
   std::string data;
 
@@ skipping 194 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 bool WebURLLoaderImpl::attachThreadedDataReceiver(
     blink::WebThreadedDataReceiver* threaded_data_receiver) {
   return context_->AttachThreadedDataReceiver(threaded_data_receiver);
 }
 
 }  // namespace content