[WIP][SVG 2/4] Make data URL handling in ResourceFetcher and WebURLLoaderImpl consistent

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.
 
 #include "content/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 318 matching lines @@
     void run() override {
       context_->HandleDataURL();
     }
 
    private:
     scoped_refptr<Context> context_;
   };
 
   // Called when the body data stream is detached from the reader side.
   void CancelBodyStreaming();
-  // We can optimize the handling of data URLs in most cases.
-  bool CanHandleDataURLRequestLocally() const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   ResourceDispatcher* resource_dispatcher_;
   scoped_ptr<blink::WebTaskRunner> web_task_runner_;
   WebReferrerPolicy referrer_policy_;
   scoped_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   scoped_ptr<MultipartResponseDelegate> multipart_delegate_;
@@ skipping 110 matching lines @@
   DCHECK(request_id_ == -1);
   request_ = request;  // Save the request.
   if (request.extraData()) {
     RequestExtraData* extra_data =
         static_cast<RequestExtraData*>(request.extraData());
     stream_override_ = extra_data->TakeStreamOverrideOwnership();
   }
 
   GURL url = request.url();
 
-  if (CanHandleDataURLRequestLocally()) {
+  if (CanHandleDataURLRequestLocally(request_,
+                                     resource_dispatcher_ != nullptr)) {
     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 {
       // TODO(alexclarke): Find a way to let blink and chromium FROM_HERE
       // coexist.
       web_task_runner_->postTask(
@@ skipping 322 matching lines @@
   if (client_) {
     // TODO(yhirano): Set |stale_copy_in_cache| appropriately if possible.
     client_->didFail(
         loader_, CreateWebURLError(request_.url(), false, net::ERR_ABORTED));
   }
 
   // Notify the browser process that the request is canceled.
   Cancel();
 }
 
-bool WebURLLoaderImpl::Context::CanHandleDataURLRequestLocally() const {
-  GURL url = request_.url();
+bool WebURLLoaderImpl::CanHandleDataURLRequestLocally(
+    const WebURLRequest& request,
+    bool resource_dispatcher_exists) {
+  GURL url = request.url();
   if (!url.SchemeIs(url::kDataScheme))
     return false;
 
   // The fast paths for data URL, Start() and HandleDataURL(), don't support
   // the downloadToFile option.
-  if (request_.downloadToFile())
+  if (request.downloadToFile())
     return false;
 
   // Data url requests from object tags may need to be intercepted as streams
   // and so need to be sent to the browser.
-  if (request_.getRequestContext() == WebURLRequest::RequestContextObject)
+  if (request.getRequestContext() == WebURLRequest::RequestContextObject)
     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.
 
 #if defined(OS_ANDROID)
   // For compatibility reasons on Android we need to expose top-level data://
   // to the browser. In tests resource_dispatcher_ can be null, and test pages
   // need to be loaded locally.
-  if (resource_dispatcher_ &&
-      request_.getFrameType() == WebURLRequest::FrameTypeTopLevel)
+  if (resource_dispatcher_exists &&
+      request.getFrameType() == WebURLRequest::FrameTypeTopLevel)
     return false;
 #endif
 
-  if (request_.getFrameType() != WebURLRequest::FrameTypeTopLevel &&
-      request_.getFrameType() != WebURLRequest::FrameTypeNested)
+  if (request.getFrameType() != WebURLRequest::FrameTypeTopLevel &&
+      request.getFrameType() != WebURLRequest::FrameTypeNested)
     return true;
 
   std::string mime_type, unused_charset;
-  if (net::DataURL::Parse(request_.url(), &mime_type, &unused_charset, NULL) &&
+  if (net::DataURL::Parse(request.url(), &mime_type, &unused_charset, NULL) &&
       mime_util::IsSupportedMimeType(mime_type))
     return true;
 
   return false;
 }
 
 void WebURLLoaderImpl::Context::HandleDataURL() {
   DCHECK_NE(defers_loading_, DEFERRED_DATA);
   if (defers_loading_ == SHOULD_DEFER) {
       defers_loading_ = DEFERRED_DATA;
@@ skipping 293 matching lines @@
 }
 
 void WebURLLoaderImpl::setLoadingTaskRunner(
     blink::WebTaskRunner* loading_task_runner) {
   // There's no guarantee on the lifetime of |loading_task_runner| so we take a
   // copy.
   context_->SetWebTaskRunner(make_scoped_ptr(loading_task_runner->clone()));
 }
 
 }  // namespace content