chrome/renderer/security_filter_peer.h

   1 // Copyright (c) 2011 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 CHROME_RENDERER_SECURITY_FILTER_PEER_H_
   6 #define CHROME_RENDERER_SECURITY_FILTER_PEER_H_
   7
   8 #include "content/public/child/request_peer.h"
   9 #include "content/public/common/resource_response_info.h"
  10 #include "content/public/common/resource_type.h"
  11
  12 // The SecurityFilterPeer is a proxy to a
  13 // content::RequestPeer instance.  It is used to pre-process
  14 // unsafe resources (such as mixed-content resource).
  15 // Call the factory method CreateSecurityFilterPeer() to obtain an instance of
  16 // SecurityFilterPeer based on the original Peer.
  17 // NOTE: subclasses should ensure they delete themselves at the end of the
  18 // OnReceiveComplete call.
  19 class SecurityFilterPeer : public content::RequestPeer {
  20  public:
  21   ~SecurityFilterPeer() override;
  22
  23   static SecurityFilterPeer* CreateSecurityFilterPeerForDeniedRequest(
  24       content::ResourceType resource_type,
  25       content::RequestPeer* peer,
  26       int os_error);
  27
  28   static SecurityFilterPeer* CreateSecurityFilterPeerForFrame(
  29       content::RequestPeer* peer,
  30       int os_error);
  31
  32   // content::RequestPeer methods.
  33   void OnUploadProgress(uint64 position, uint64 size) override;
  34   bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
  35                           const content::ResourceResponseInfo& info) override;
  36   void OnReceivedResponse(const content::ResourceResponseInfo& info) override;
  37   void OnDownloadedData(int len, int encoded_data_length) override {}
  38   void OnReceivedData(const char* data,
  39                       int data_length,
  40                       int encoded_data_length) override;
  41   void OnCompletedRequest(int error_code,
  42                           bool was_ignored_by_handler,
  43                           bool stale_copy_in_cache,
  44                           const std::string& security_info,
  45                           const base::TimeTicks& completion_time,
  46                           int64 total_transfer_size) override;
  47
  48  protected:
  49   explicit SecurityFilterPeer(content::RequestPeer* peer);
  50
  51   content::RequestPeer* original_peer_;
  52
  53  private:
  54   DISALLOW_COPY_AND_ASSIGN(SecurityFilterPeer);
  55 };
  56
  57 // The BufferedPeer reads all the data of the request into an internal buffer.
  58 // Subclasses should implement DataReady() to process the data as necessary.
  59 class BufferedPeer : public SecurityFilterPeer {
  60  public:
  61   BufferedPeer(content::RequestPeer* peer, const std::string& mime_type);
  62   ~BufferedPeer() override;
  63
  64   // content::RequestPeer Implementation.
  65   void OnReceivedResponse(const content::ResourceResponseInfo& info) override;
  66   void OnReceivedData(const char* data,
  67                       int data_length,
  68                       int encoded_data_length) override;
  69   void OnCompletedRequest(int error_code,
  70                           bool was_ignored_by_handler,
  71                           bool stale_copy_in_cache,
  72                           const std::string& security_info,
  73                           const base::TimeTicks& completion_time,
  74                           int64 total_transfer_size) override;
  75
  76  protected:
  77   // Invoked when the entire request has been processed before the data is sent
  78   // to the original peer, giving an opportunity to subclasses to process the
  79   // data in data_.  If this method returns true, the data is fed to the
  80   // original peer, if it returns false, an error is sent instead.
  81   virtual bool DataReady() = 0;
  82
  83   content::ResourceResponseInfo response_info_;
  84   std::string data_;
  85
  86  private:
  87   std::string mime_type_;
  88
  89   DISALLOW_COPY_AND_ASSIGN(BufferedPeer);
  90 };
  91
  92 // The ReplaceContentPeer cancels the request and serves the provided data as
  93 // content instead.
  94 // TODO(jcampan): For now the resource is still being fetched, but ignored, as
  95 // once we have provided the replacement content, the associated pending request
  96 // in ResourceDispatcher is removed and further OnReceived* notifications are
  97 // ignored.
  98 class ReplaceContentPeer : public SecurityFilterPeer {
  99  public:
 100   ReplaceContentPeer(content::RequestPeer* peer,
 101                      const std::string& mime_type,
 102                      const std::string& data);
 103   ~ReplaceContentPeer() override;
 104
 105   // content::RequestPeer Implementation.
 106   void OnReceivedResponse(const content::ResourceResponseInfo& info) override;
 107   void OnReceivedData(const char* data,
 108                       int data_length,
 109                       int encoded_data_length) override;
 110   void OnCompletedRequest(int error_code,
 111                           bool was_ignored_by_handler,
 112                           bool stale_copy_in_cache,
 113                           const std::string& security_info,
 114                           const base::TimeTicks& completion_time,
 115                           int64 total_transfer_size) override;
 116
 117  private:
 118   content::ResourceResponseInfo response_info_;
 119   std::string mime_type_;
 120   std::string data_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(ReplaceContentPeer);
 123 };
 124
 125 #endif  // CHROME_RENDERER_SECURITY_FILTER_PEER_H_