Properly handle defers loading in WebURLLoaderImpl for data uris

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 <algorithm>
 #include <deque>
+#include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "content/child/ftp_directory_listing_response_delegate.h"
 #include "content/child/multipart_response_delegate.h"
@@ skipping 326 matching lines @@
   scoped_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   scoped_ptr<MultipartResponseDelegate> multipart_delegate_;
   scoped_ptr<ResourceLoaderBridge> completed_bridge_;
   scoped_ptr<StreamOverrideParameters> stream_override_;
   mojo::ScopedDataPipeProducerHandle body_stream_writer_;
   mojo::common::HandleWatcher body_stream_writer_watcher_;
   // TODO(yhirano): Delete this buffer after implementing the back-pressure
   // mechanism.
   std::deque<char> body_stream_buffer_;
   bool got_all_stream_body_data_;
+  enum DeferState {NOT_DEFERRING, SHOULD_DEFER, DEFERRED_DATA};
+  DeferState defers_loading_;
 };
 
 WebURLLoaderImpl::Context::Context(
     WebURLLoaderImpl* loader,
     ResourceDispatcher* resource_dispatcher,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : loader_(loader),
       client_(NULL),
       resource_dispatcher_(resource_dispatcher),
       task_runner_(task_runner),
       referrer_policy_(blink::WebReferrerPolicyDefault),
-      got_all_stream_body_data_(false) {
+      got_all_stream_body_data_(false),
+      defers_loading_(NOT_DEFERRING)  {
 }
 
 void WebURLLoaderImpl::Context::Cancel() {
   if (bridge_) {
     bridge_->Cancel();
     bridge_.reset();
   }
 
   // Ensure that we do not notify the multipart delegate anymore as it has
   // its own pointer to the client.
   if (multipart_delegate_)
     multipart_delegate_->Cancel();
   // Ditto for the ftp delegate.
   if (ftp_listing_delegate_)
     ftp_listing_delegate_->Cancel();
 
   // Do not make any further calls to the client.
   client_ = NULL;
   loader_ = NULL;
 }
 
 void WebURLLoaderImpl::Context::SetDefersLoading(bool value) {
   if (bridge_)
     bridge_->SetDefersLoading(value);
+  if (value && defers_loading_ == NOT_DEFERRING) {
+    defers_loading_ = SHOULD_DEFER;
+  } else if (!value && defers_loading_ != NOT_DEFERRING) {
+    if (defers_loading_ == DEFERRED_DATA) {
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&Context::HandleDataURL, this));
+    }
+    defers_loading_ = NOT_DEFERRING;
+  }
 }
 
 void WebURLLoaderImpl::Context::DidChangePriority(
     WebURLRequest::Priority new_priority, int intra_priority_value) {
   if (bridge_)
     bridge_->DidChangePriority(
         ConvertWebKitPriorityToNetPriority(new_priority), intra_priority_value);
 }
 
 bool WebURLLoaderImpl::Context::AttachThreadedDataReceiver(
@@ skipping 428 matching lines @@
 
   std::string mime_type, unused_charset;
   if (net::DataURL::Parse(request_.url(), &mime_type, &unused_charset, NULL) &&
       net::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;
+      return;
+  }
+
   ResourceResponseInfo info;
   std::string data;
 
   int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
 
   if (error_code == net::OK) {
     OnReceivedResponse(info);
     if (!data.empty())
       OnReceivedData(data.data(), data.size(), 0);
   }
@@ skipping 308 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