service worker: Refactor blob reading out of ServiceWorkerURLRequestJob

content/browser/service_worker/service_worker_url_request_job.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_URL_REQUEST_JOB_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_URL_REQUEST_JOB_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 28 matching lines @@
 
 namespace storage {
 class BlobDataHandle;
 class BlobStorageContext;
 }
 
 namespace content {
 
 class ResourceContext;
 class ResourceRequestBodyImpl;
+class ServiceWorkerBlobReader;
 class ServiceWorkerContextCore;
 class ServiceWorkerFetchDispatcher;
 class ServiceWorkerProviderHost;
 class ServiceWorkerVersion;
 class Stream;
 
 class CONTENT_EXPORT ServiceWorkerURLRequestJob
     : public net::URLRequestJob,
-      public net::URLRequest::Delegate,
       public StreamReadObserver,
       public StreamRegisterObserver {
  public:
   class CONTENT_EXPORT Delegate {
    public:
     virtual ~Delegate() {}
 
     // Will be invoked before the request is restarted. The caller
     // can use this opportunity to grab state from the
     // ServiceWorkerURLRequestJob to determine how it should behave when the
@@ skipping 60 matching lines @@
   void Kill() override;
   net::LoadState GetLoadState() const override;
   bool GetCharset(std::string* charset) override;
   bool GetMimeType(std::string* mime_type) const override;
   void GetResponseInfo(net::HttpResponseInfo* info) override;
   void GetLoadTimingInfo(net::LoadTimingInfo* load_timing_info) const override;
   int GetResponseCode() const override;
   void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers) override;
   int ReadRawData(net::IOBuffer* buf, int buf_size) override;
 
-  // net::URLRequest::Delegate overrides that read the blob from the
-  // ServiceWorkerFetchResponse.
-  void OnReceivedRedirect(net::URLRequest* request,
-                          const net::RedirectInfo& redirect_info,
-                          bool* defer_redirect) override;
-  void OnAuthRequired(net::URLRequest* request,
-                      net::AuthChallengeInfo* auth_info) override;
-  void OnCertificateRequested(
-      net::URLRequest* request,
-      net::SSLCertRequestInfo* cert_request_info) override;
-  void OnSSLCertificateError(net::URLRequest* request,
-                             const net::SSLInfo& ssl_info,
-                             bool fatal) override;
-  void OnResponseStarted(net::URLRequest* request) override;
-  void OnReadCompleted(net::URLRequest* request, int bytes_read) override;
-
   // StreamObserver override:
   void OnDataAvailable(Stream* stream) override;
 
   // StreamRegisterObserver override:
   void OnStreamRegistered(Stream* stream) override;
 
+  //----------------------------------------------------------------------------
+  // The following are intended for use by ServiceWorkerBlobReader.
+  void OnResponseStarted();
+  void OnReadRawDataComplete(int bytes_read);
+  void RecordResult(ServiceWorkerMetrics::URLRequestJobResult result);
+  //----------------------------------------------------------------------------
+
   base::WeakPtr<ServiceWorkerURLRequestJob> GetWeakPtr();
 
  private:
   class BlobConstructionWaiter;
 
   enum ResponseType {
     NOT_DETERMINED,
     FALLBACK_TO_NETWORK,
     FALLBACK_TO_RENDERER,  // Use this when falling back with CORS check
     FORWARD_TO_SERVICE_WORKER,
@@ skipping 49 matching lines @@
   // This can be called after StartRequest.
   void FinalizeFallbackToRenderer();
 
   // True if need to send back a response with fall_back_required set as true to
   // trigger subsequent network requests with CORS checking.
   bool IsFallbackToRendererNeeded() const;
 
   // For UMA.
   void SetResponseBodyType(ResponseBodyType type);
   bool ShouldRecordResult();
-  void RecordResult(ServiceWorkerMetrics::URLRequestJobResult result);
   void RecordStatusZeroResponseError(
       blink::WebServiceWorkerResponseError error);
 
   // Releases the resources for streaming.
   void ClearStream();
 
   const net::HttpResponseInfo* http_info() const;
 
   // Invoke callbacks before invoking corresponding URLRequestJob methods.
   void NotifyHeadersComplete();
@@ skipping 28 matching lines @@
   // Headers that have not yet been committed to |http_response_info_|.
   scoped_refptr<net::HttpResponseHeaders> http_response_headers_;
   GURL response_url_;
   blink::WebServiceWorkerResponseType service_worker_response_type_;
 
   // Used when response type is FORWARD_TO_SERVICE_WORKER.
   std::unique_ptr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
   std::string client_id_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
   const ResourceContext* resource_context_;
-  std::unique_ptr<net::URLRequest> blob_request_;
+  std::unique_ptr<ServiceWorkerBlobReader> blob_reader_;
   scoped_refptr<Stream> stream_;
   GURL waiting_stream_url_;
   scoped_refptr<net::IOBuffer> stream_pending_buffer_;
   int stream_pending_buffer_size_;
 
   FetchRequestMode request_mode_;
   FetchCredentialsMode credentials_mode_;
   FetchRedirectMode redirect_mode_;
   const ResourceType resource_type_;
   RequestContextType request_context_type_;
@@ skipping 20 matching lines @@
   EmbeddedWorkerStatus initial_worker_status_ = EmbeddedWorkerStatus::STOPPED;
 
   base::WeakPtrFactory<ServiceWorkerURLRequestJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerURLRequestJob);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_URL_REQUEST_JOB_H_