src/content/public/browser/resource_dispatcher_host_delegate.h

   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_