Home | History | Annotate | Download | only in browser 
      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_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
      6 #define CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "content/common/content_export.h"
     13 #include "webkit/common/resource_type.h"
     14 
     15 class GURL;
     16 template <class T> class ScopedVector;
     17 
     18 namespace appcache {
     19 class AppCacheService;
     20 }
     21 
     22 namespace content {
     23 class ResourceContext;
     24 class ResourceThrottle;
     25 class StreamHandle;
     26 struct Referrer;
     27 struct ResourceResponse;
     28 }
     29 
     30 namespace IPC {
     31 class Sender;
     32 }
     33 
     34 namespace net {
     35 class AuthChallengeInfo;
     36 class URLRequest;
     37 }
     38 
     39 namespace content {
     40 
     41 class ResourceDispatcherHostLoginDelegate;
     42 
     43 // Interface that the embedder provides to ResourceDispatcherHost to allow
     44 // observing and modifying requests.
     45 class CONTENT_EXPORT ResourceDispatcherHostDelegate {
     46  public:
     47   // Called when a request begins. Return false to abort the request.
     48   virtual bool ShouldBeginRequest(
     49       int child_id,
     50       int route_id,
     51       const std::string& method,
     52       const GURL& url,
     53       ResourceType::Type resource_type,
     54       ResourceContext* resource_context);
     55 
     56   // Called after ShouldBeginRequest to allow the embedder to add resource
     57   // throttles.
     58   virtual void RequestBeginning(
     59       net::URLRequest* request,
     60       ResourceContext* resource_context,
     61       appcache::AppCacheService* appcache_service,
     62       ResourceType::Type resource_type,
     63       int child_id,
     64       int route_id,
     65       ScopedVector<ResourceThrottle>* throttles);
     66 
     67   // Allows an embedder to add additional resource handlers for a download.
     68   // |must_download| is set if the request must be handled as a download.
     69   virtual void DownloadStarting(
     70       net::URLRequest* request,
     71       ResourceContext* resource_context,
     72       int child_id,
     73       int route_id,
     74       int request_id,
     75       bool is_content_initiated,
     76       bool must_download,
     77       ScopedVector<ResourceThrottle>* throttles);
     78 
     79   // Creates a ResourceDispatcherHostLoginDelegate that asks the user for a
     80   // username and password.
     81   virtual ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
     82       net::AuthChallengeInfo* auth_info, net::URLRequest* request);
     83 
     84   // Launches the url for the given tab. Returns true if an attempt to handle
     85   // the url was made, e.g. by launching an app. Note that this does not
     86   // guarantee that the app successfully handled it.
     87   virtual bool HandleExternalProtocol(const GURL& url,
     88                                       int child_id,
     89                                       int route_id);
     90 
     91   // Returns true if we should force the given resource to be downloaded.
     92   // Otherwise, the content layer decides.
     93   virtual bool ShouldForceDownloadResource(
     94       const GURL& url, const std::string& mime_type);
     95 
     96   // Returns true and sets |origin| if a Stream should be created for the
     97   // resource.
     98   // If true is returned, a new Stream will be created and OnStreamCreated()
     99   // will be called with
    100   // - a StreamHandle instance for the Stream. The handle contains the URL for
    101   //   reading the Stream etc.
    102   // The Stream's origin will be set to |origin|.
    103   //
    104   // If the stream will be rendered in a BrowserPlugin, |payload| will contain
    105   // the data that should be given to the old ResourceHandler to forward to the
    106   // renderer process.
    107   virtual bool ShouldInterceptResourceAsStream(
    108       net::URLRequest* request,
    109       const std::string& mime_type,
    110       GURL* origin,
    111       std::string* payload);
    112 
    113   // Informs the delegate that a Stream was created. The Stream can be read from
    114   // the blob URL of the Stream, but can only be read once.
    115   virtual void OnStreamCreated(
    116       net::URLRequest* request,
    117       scoped_ptr<content::StreamHandle> stream);
    118 
    119   // Informs the delegate that a response has started.
    120   virtual void OnResponseStarted(
    121       net::URLRequest* request,
    122       ResourceContext* resource_context,
    123       ResourceResponse* response,
    124       IPC::Sender* sender);
    125 
    126   // Informs the delegate that a request has been redirected.
    127   virtual void OnRequestRedirected(
    128       const GURL& redirect_url,
    129       net::URLRequest* request,
    130       ResourceContext* resource_context,
    131       ResourceResponse* response);
    132 
    133   // Notification that a request has completed.
    134   virtual void RequestComplete(net::URLRequest* url_request);
    135 
    136  protected:
    137   ResourceDispatcherHostDelegate();
    138   virtual ~ResourceDispatcherHostDelegate();
    139 };
    140 
    141 }  // namespace content
    142 
    143 #endif  // CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
    144