chrome_frame/plugin_url_request.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_FRAME_PLUGIN_URL_REQUEST_H_
   6 #define CHROME_FRAME_PLUGIN_URL_REQUEST_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/memory/ref_counted.h"
  12 #include "base/time/time.h"
  13 #include "base/win/scoped_comptr.h"
  14 #include "chrome_frame/chrome_frame_delegate.h"
  15 #include "chrome_frame/urlmon_upload_data_stream.h"
  16 #include "ipc/ipc_message.h"
  17 #include "net/base/host_port_pair.h"
  18 #include "net/base/upload_data.h"
  19 #include "net/url_request/url_request_status.h"
  20 #include "webkit/glue/resource_type.h"
  21
  22 class PluginUrlRequest;
  23 class PluginUrlRequestDelegate;
  24 class PluginUrlRequestManager;
  25
  26 class DECLSPEC_NOVTABLE PluginUrlRequestDelegate {  // NOLINT
  27  public:
  28   virtual void OnResponseStarted(
  29       int request_id, const char* mime_type, const char* headers, int size,
  30       base::Time last_modified, const std::string& redirect_url,
  31       int redirect_status, const net::HostPortPair& socket_address,
  32       uint64 upload_size) = 0;
  33   virtual void OnReadComplete(int request_id, const std::string& data) = 0;
  34   virtual void OnResponseEnd(int request_id,
  35                              const net::URLRequestStatus& status) = 0;
  36   virtual void AddPrivacyDataForUrl(const std::string& url,
  37                                     const std::string& policy_ref,
  38                                     int32 flags) {}
  39   virtual void OnCookiesRetrieved(bool success, const GURL& url,
  40                                   const std::string& cookie_string,
  41                                   int cookie_id) = 0;
  42  protected:
  43   PluginUrlRequestDelegate() {}
  44   ~PluginUrlRequestDelegate() {}
  45 };
  46
  47 class DECLSPEC_NOVTABLE PluginUrlRequestManager {  // NOLINT
  48  public:
  49   PluginUrlRequestManager() : delegate_(NULL), enable_frame_busting_(true) {}
  50   virtual ~PluginUrlRequestManager() {}
  51
  52   void set_frame_busting(bool enable) {
  53     enable_frame_busting_ = enable;
  54   }
  55
  56   virtual void set_delegate(PluginUrlRequestDelegate* delegate) {
  57     delegate_ = delegate;
  58   }
  59
  60   enum ThreadSafeFlags {
  61     NOT_THREADSAFE               = 0x00,
  62     START_REQUEST_THREADSAFE     = 0x01,
  63     STOP_REQUEST_THREADSAFE      = 0x02,
  64     READ_REQUEST_THREADSAFE      = 0x04,
  65     DOWNLOAD_REQUEST_THREADSAFE  = 0x08,
  66     COOKIE_REQUEST_THREADSAFE    = 0x10
  67   };
  68   virtual ThreadSafeFlags GetThreadSafeFlags() = 0;
  69
  70   // These are called directly from Automation Client when network related
  71   // automation messages are received from Chrome.
  72   // Strip 'tab' handle and forward to the virtual methods implemented by
  73   // derived classes.
  74   void StartUrlRequest(int request_id,
  75                        const AutomationURLRequest& request_info) {
  76     StartRequest(request_id, request_info);
  77   }
  78
  79   void ReadUrlRequest(int request_id, int bytes_to_read) {
  80     ReadRequest(request_id, bytes_to_read);
  81   }
  82
  83   void EndUrlRequest(int request_id, const net::URLRequestStatus& s) {
  84     EndRequest(request_id);
  85   }
  86
  87   void DownloadUrlRequestInHost(int request_id) {
  88     DownloadRequestInHost(request_id);
  89   }
  90
  91   void StopAllRequests() {
  92     StopAll();
  93   }
  94
  95   void GetCookiesFromHost(const GURL& url, int cookie_id) {
  96     GetCookiesForUrl(url, cookie_id);
  97   }
  98
  99   void SetCookiesInHost(const GURL& url, const std::string& cookie) {
 100     SetCookiesForUrl(url, cookie);
 101   }
 102
 103  protected:
 104   PluginUrlRequestDelegate* delegate_;
 105   bool enable_frame_busting_;
 106
 107  private:
 108   virtual void StartRequest(
 109       int request_id, const AutomationURLRequest& request_info) = 0;
 110   virtual void ReadRequest(int request_id, int bytes_to_read) = 0;
 111   virtual void EndRequest(int request_id) = 0;
 112   virtual void DownloadRequestInHost(int request_id) = 0;
 113   virtual void StopAll() = 0;
 114   virtual void GetCookiesForUrl(const GURL& url, int cookie_id) = 0;
 115   virtual void SetCookiesForUrl(const GURL& url, const std::string& cookie) = 0;
 116 };
 117
 118 // Used as base class. Holds Url request properties (url, method, referrer..)
 119 class PluginUrlRequest {
 120  public:
 121   PluginUrlRequest();
 122   ~PluginUrlRequest();
 123
 124   bool Initialize(PluginUrlRequestDelegate* delegate,
 125       int remote_request_id, const std::string& url, const std::string& method,
 126       const std::string& referrer, const std::string& extra_headers,
 127       net::UploadData* upload_data, ResourceType::Type resource_type,
 128       bool enable_frame_busting_, int load_flags);
 129
 130   // Accessors.
 131   int id() const {
 132     return remote_request_id_;
 133   }
 134
 135   const std::string& url() const {
 136     return url_;
 137   }
 138
 139   const std::string& method() const {
 140     return method_;
 141   }
 142
 143   const std::string& referrer() const {
 144     return referrer_;
 145   }
 146
 147   const std::string& extra_headers() const {
 148     return extra_headers_;
 149   }
 150
 151   uint64 post_data_len() const {
 152     return post_data_len_;
 153   }
 154
 155   bool is_chunked_upload() const {
 156     return is_chunked_upload_;
 157   }
 158
 159  protected:
 160   HRESULT get_upload_data(IStream** ret) {
 161     DCHECK(ret);
 162     if (!upload_data_.get())
 163       return S_FALSE;
 164     *ret = upload_data_.get();
 165     (*ret)->AddRef();
 166     return S_OK;
 167   }
 168
 169   void set_url(const std::string& url) {
 170     url_ = url;
 171   }
 172
 173   void SendData();
 174   bool enable_frame_busting_;
 175
 176   PluginUrlRequestDelegate* delegate_;
 177   int remote_request_id_;
 178   uint64 post_data_len_;
 179   std::string url_;
 180   std::string method_;
 181   std::string referrer_;
 182   std::string extra_headers_;
 183   ResourceType::Type resource_type_;
 184   int load_flags_;
 185   base::win::ScopedComPtr<IStream> upload_data_;
 186   bool is_chunked_upload_;
 187   // Contains the ip address and port of the destination host.
 188   net::HostPortPair socket_address_;
 189 };
 190
 191 #endif  // CHROME_FRAME_PLUGIN_URL_REQUEST_H_