Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/resource_loader.h

 // 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_BROWSER_LOADER_RESOURCE_LOADER_H_
 #define CONTENT_BROWSER_LOADER_RESOURCE_LOADER_H_
 
 #include <memory>
 
 #include "base/callback_forward.h"
@@ skipping 81 matching lines @@
   // otherwise.
   void Resume(bool called_from_resource_controller);
   void Cancel();
   void CancelAndIgnore();
   void CancelWithError(int error_code);
 
   void StartRequestInternal();
   void CancelRequestInternal(int error, bool from_renderer);
   void FollowDeferredRedirectInternal();
   void CompleteResponseStarted();
-  // If |handle_result_async| is true, the result of a read that completed
-  // synchronously will be handled asynchronously, except on EOF or error.
+  // If |handle_result_async| is true, the result of the following read will be
+  // handled asynchronously if it completes synchronously, unless it's EOF or an
+  // error. This is to prevent a single request from blocking the thread for too
+  // long.
+  void PrepareToReadMore(bool handle_result_async);
   void ReadMore(bool handle_result_async);
   void ResumeReading();
   // Passes a read result to the handler.
   void CompleteRead(int bytes_read);
   void ResponseCompleted();
   void CallDidFinishLoading();
   void RecordHistograms();
 
   bool is_deferred() const { return deferred_stage_ != DEFERRED_NONE; }
 
@@ skipping 12 matching lines @@
   enum DeferredStage {
     DEFERRED_NONE,
     // Magic deferral "stage" which means that the code is currently in a
     // recursive call from the ResourceLoader. When in this state, Resume() does
     // nothing but update the deferral state, and when the stack is unwound back
     // up to the ResourceLoader, the request will be continued. This is used to
     // prevent the stack from getting too deep.
     DEFERRED_SYNC,
     DEFERRED_START,
     DEFERRED_REDIRECT,
+    DEFERRED_ON_WILL_READ,
     DEFERRED_READ,
     DEFERRED_RESPONSE_COMPLETE,
     DEFERRED_FINISH
   };
   DeferredStage deferred_stage_;
 
   class ScopedDeferral;
 
   std::unique_ptr<net::URLRequest> request_;
   std::unique_ptr<ResourceHandler> handler_;
@@ skipping 14 matching lines @@
 
   // Instrumentation add to investigate http://crbug.com/503306.
   // TODO(mmenke): Remove once bug is fixed.
   int times_cancelled_before_request_start_;
   bool started_request_;
   int times_cancelled_after_request_start_;
 
   // Stores the URL from a deferred redirect.
   GURL deferred_redirect_url_;
 
+  // Read buffer and its size.  Class members as OnWillRead can complete
+  // asynchronously.
+  scoped_refptr<net::IOBuffer> read_buffer_;
+  int read_buffer_size_;
+
   base::WeakPtrFactory<ResourceLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceLoader);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_LOADER_H_