Home | History | Annotate | Download | only in loader 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CONTENT_BROWSER_LOADER_RESOURCE_LOADER_H_
      6 #define CONTENT_BROWSER_LOADER_RESOURCE_LOADER_H_
      7 
      8 #include "base/gtest_prod_util.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/memory/weak_ptr.h"
     11 #include "content/browser/loader/resource_handler.h"
     12 #include "content/browser/ssl/ssl_error_handler.h"
     13 #include "content/common/content_export.h"
     14 #include "content/public/browser/resource_controller.h"
     15 #include "net/url_request/url_request.h"
     16 
     17 namespace net {
     18 class ClientCertStore;
     19 }
     20 
     21 namespace content {
     22 class ResourceDispatcherHostLoginDelegate;
     23 class ResourceLoaderDelegate;
     24 class ResourceRequestInfoImpl;
     25 class SSLClientAuthHandler;
     26 
     27 // This class is responsible for driving the URLRequest (i.e., calling Start,
     28 // Read, and servicing events).  It has a ResourceHandler, which is typically a
     29 // chain of ResourceHandlers, and is the ResourceController for its handler.
     30 class CONTENT_EXPORT ResourceLoader : public net::URLRequest::Delegate,
     31                                       public SSLErrorHandler::Delegate,
     32                                       public ResourceController {
     33  public:
     34   ResourceLoader(scoped_ptr<net::URLRequest> request,
     35                  scoped_ptr<ResourceHandler> handler,
     36                  ResourceLoaderDelegate* delegate);
     37   virtual ~ResourceLoader();
     38 
     39   void StartRequest();
     40   void CancelRequest(bool from_renderer);
     41 
     42   void ReportUploadProgress();
     43 
     44   bool is_transferring() const { return is_transferring_; }
     45   void MarkAsTransferring(const GURL& target_url);
     46   void WillCompleteTransfer();
     47   void CompleteTransfer(scoped_ptr<ResourceHandler> new_handler);
     48 
     49   net::URLRequest* request() { return request_.get(); }
     50   ResourceRequestInfoImpl* GetRequestInfo();
     51 
     52   void ClearLoginDelegate();
     53   void ClearSSLClientAuthHandler();
     54 
     55   // IPC message handlers:
     56   void OnUploadProgressACK();
     57 
     58  private:
     59   FRIEND_TEST_ALL_PREFIXES(ResourceLoaderTest, ClientCertStoreLookup);
     60 
     61   ResourceLoader(scoped_ptr<net::URLRequest> request,
     62                  scoped_ptr<ResourceHandler> handler,
     63                  ResourceLoaderDelegate* delegate,
     64                  scoped_ptr<net::ClientCertStore> client_cert_store);
     65 
     66   // Initialization logic shared between the public and private constructor.
     67   void Init(scoped_ptr<net::URLRequest> request,
     68             scoped_ptr<ResourceHandler> handler,
     69             ResourceLoaderDelegate* delegate,
     70             scoped_ptr<net::ClientCertStore> client_cert_store);
     71 
     72   // net::URLRequest::Delegate implementation:
     73   virtual void OnReceivedRedirect(net::URLRequest* request,
     74                                   const GURL& new_url,
     75                                   bool* defer) OVERRIDE;
     76   virtual void OnAuthRequired(net::URLRequest* request,
     77                               net::AuthChallengeInfo* info) OVERRIDE;
     78   virtual void OnCertificateRequested(net::URLRequest* request,
     79                                       net::SSLCertRequestInfo* info) OVERRIDE;
     80   virtual void OnSSLCertificateError(net::URLRequest* request,
     81                                      const net::SSLInfo& info,
     82                                      bool fatal) OVERRIDE;
     83   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
     84   virtual void OnReadCompleted(net::URLRequest* request,
     85                                int bytes_read) OVERRIDE;
     86 
     87   // SSLErrorHandler::Delegate implementation:
     88   virtual void CancelSSLRequest(const GlobalRequestID& id,
     89                                 int error,
     90                                 const net::SSLInfo* ssl_info) OVERRIDE;
     91   virtual void ContinueSSLRequest(const GlobalRequestID& id) OVERRIDE;
     92 
     93   // ResourceController implementation:
     94   virtual void Resume() OVERRIDE;
     95   virtual void Cancel() OVERRIDE;
     96   virtual void CancelAndIgnore() OVERRIDE;
     97   virtual void CancelWithError(int error_code) OVERRIDE;
     98 
     99   void StartRequestInternal();
    100   void CancelRequestInternal(int error, bool from_renderer);
    101   void CompleteResponseStarted();
    102   void StartReading(bool is_continuation);
    103   void ResumeReading();
    104   void ReadMore(int* bytes_read);
    105   void CompleteRead(int bytes_read);
    106   void ResponseCompleted();
    107   void CallDidFinishLoading();
    108 
    109   bool is_deferred() const { return deferred_stage_ != DEFERRED_NONE; }
    110 
    111   enum DeferredStage {
    112     DEFERRED_NONE,
    113     DEFERRED_START,
    114     DEFERRED_REDIRECT,
    115     DEFERRED_READ,
    116     DEFERRED_FINISH
    117   };
    118   DeferredStage deferred_stage_;
    119 
    120   scoped_ptr<net::URLRequest> request_;
    121   scoped_ptr<ResourceHandler> handler_;
    122   ResourceLoaderDelegate* delegate_;
    123 
    124   scoped_refptr<ResourceDispatcherHostLoginDelegate> login_delegate_;
    125   scoped_refptr<SSLClientAuthHandler> ssl_client_auth_handler_;
    126 
    127   uint64 last_upload_position_;
    128   bool waiting_for_upload_progress_ack_;
    129   base::TimeTicks last_upload_ticks_;
    130   base::TimeTicks read_deferral_start_time_;
    131 
    132   // Indicates that we are in a state of being transferred to a new downstream
    133   // consumer.  We are waiting for a notification to complete the transfer, at
    134   // which point we'll receive a new ResourceHandler.
    135   bool is_transferring_;
    136 
    137   scoped_ptr<net::ClientCertStore> client_cert_store_;
    138 
    139   base::WeakPtrFactory<ResourceLoader> weak_ptr_factory_;
    140 
    141   DISALLOW_COPY_AND_ASSIGN(ResourceLoader);
    142 };
    143 
    144 }  // namespace content
    145 
    146 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_LOADER_H_
    147