| OLD | NEW |
|---|
| (Empty) |
| 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 CHROME_FRAME_URLMON_URL_REQUEST_PRIVATE_H_ | |
| 6 #define CHROME_FRAME_URLMON_URL_REQUEST_PRIVATE_H_ | |
| 7 | |
| 8 #include <atlbase.h> | |
| 9 #include <atlcom.h> | |
| 10 | |
| 11 #include <string> | |
| 12 | |
| 13 #include "base/gtest_prod_util.h" | |
| 14 #include "base/threading/platform_thread.h" | |
| 15 #include "net/base/net_errors.h" | |
| 16 #include "net/http/http_response_headers.h" | |
| 17 #include "net/url_request/url_request_status.h" | |
| 18 | |
| 19 class UrlmonUrlRequest | |
| 20 : public CComObjectRootEx<CComMultiThreadModel>, | |
| 21 public PluginUrlRequest, | |
| 22 public IServiceProviderImpl<UrlmonUrlRequest>, | |
| 23 public IBindStatusCallback, | |
| 24 public IHttpNegotiate, | |
| 25 public IAuthenticate, | |
| 26 public IHttpSecurity { | |
| 27 public: | |
| 28 virtual bool Start(); | |
| 29 virtual void Stop(); | |
| 30 virtual bool Read(int bytes_to_read); | |
| 31 | |
| 32 // Special function needed by ActiveDocument::Load() | |
| 33 HRESULT InitPending(const GURL& url, IMoniker* moniker, IBindCtx* bind_ctx, | |
| 34 bool enable_frame_busting, bool privileged_mode, | |
| 35 HWND notification_window, IStream* cache); | |
| 36 | |
| 37 // Used from "DownloadRequestInHost". | |
| 38 // Callback will be invoked either right away (if operation is finished) or | |
| 39 // from inside ::OnStopBinding() when it is safe to reuse the bind_context. | |
| 40 typedef base::Callback<void(IMoniker*, IBindCtx*, IStream*, const char*)> | |
| 41 TerminateBindCallback; | |
| 42 void TerminateBind(const TerminateBindCallback& callback); | |
| 43 | |
| 44 // Parent Window for UrlMon error dialogs | |
| 45 void set_parent_window(HWND parent_window) { | |
| 46 parent_window_ = parent_window; | |
| 47 } | |
| 48 | |
| 49 // This function passes information on whether ChromeFrame is running in | |
| 50 // privileged mode. | |
| 51 void set_privileged_mode(bool privileged_mode) { | |
| 52 privileged_mode_ = privileged_mode; | |
| 53 } | |
| 54 | |
| 55 // Returns a string in the form " id: %i Obj: %X URL: %s" which is useful | |
| 56 // to identify request objects in the log. | |
| 57 std::string me() const; | |
| 58 | |
| 59 protected: | |
| 60 UrlmonUrlRequest(); | |
| 61 ~UrlmonUrlRequest(); | |
| 62 | |
| 63 BEGIN_COM_MAP(UrlmonUrlRequest) | |
| 64 COM_INTERFACE_ENTRY(IHttpNegotiate) | |
| 65 COM_INTERFACE_ENTRY(IServiceProvider) | |
| 66 COM_INTERFACE_ENTRY(IBindStatusCallback) | |
| 67 COM_INTERFACE_ENTRY(IWindowForBindingUI) | |
| 68 COM_INTERFACE_ENTRY(IAuthenticate) | |
| 69 COM_INTERFACE_ENTRY(IHttpSecurity) | |
| 70 END_COM_MAP() | |
| 71 | |
| 72 BEGIN_SERVICE_MAP(UrlmonUrlRequest) | |
| 73 SERVICE_ENTRY(IID_IHttpNegotiate); | |
| 74 END_SERVICE_MAP() | |
| 75 | |
| 76 // IBindStatusCallback implementation | |
| 77 STDMETHOD(OnStartBinding)(DWORD reserved, IBinding* binding); | |
| 78 STDMETHOD(GetPriority)(LONG* priority); | |
| 79 STDMETHOD(OnLowResource)(DWORD reserved); | |
| 80 STDMETHOD(OnProgress)(ULONG progress, ULONG max_progress, | |
| 81 ULONG status_code, LPCWSTR status_text); | |
| 82 STDMETHOD(OnStopBinding)(HRESULT result, LPCWSTR error); | |
| 83 STDMETHOD(GetBindInfo)(DWORD* bind_flags, BINDINFO* bind_info); | |
| 84 STDMETHOD(OnDataAvailable)(DWORD flags, DWORD size, FORMATETC* formatetc, | |
| 85 STGMEDIUM* storage); | |
| 86 STDMETHOD(OnObjectAvailable)(REFIID iid, IUnknown* object); | |
| 87 | |
| 88 // IHttpNegotiate implementation | |
| 89 STDMETHOD(BeginningTransaction)(const wchar_t* url, | |
| 90 const wchar_t* current_headers, DWORD reserved, | |
| 91 wchar_t** additional_headers); | |
| 92 STDMETHOD(OnResponse)(DWORD dwResponseCode, const wchar_t* response_headers, | |
| 93 const wchar_t* request_headers, wchar_t** additional_headers); | |
| 94 | |
| 95 // IWindowForBindingUI implementation. This interface is used typically to | |
| 96 // query the window handle which URLMON uses as the parent of error dialogs. | |
| 97 STDMETHOD(GetWindow)(REFGUID guid_reason, HWND* parent_window); | |
| 98 | |
| 99 // IAuthenticate implementation. Used to return the parent window for the | |
| 100 // dialog displayed by IE for authenticating with a proxy. | |
| 101 STDMETHOD(Authenticate)(HWND* parent_window, LPWSTR* user_name, | |
| 102 LPWSTR* password); | |
| 103 | |
| 104 // IHttpSecurity implementation. | |
| 105 STDMETHOD(OnSecurityProblem)(DWORD problem); | |
| 106 | |
| 107 void set_pending(bool pending) { | |
| 108 pending_ = pending; | |
| 109 } | |
| 110 | |
| 111 bool pending() const { | |
| 112 return pending_; | |
| 113 } | |
| 114 | |
| 115 bool terminate_requested() const { | |
| 116 return !terminate_bind_callback_.is_null(); | |
| 117 } | |
| 118 | |
| 119 std::string response_headers() { | |
| 120 return response_headers_; | |
| 121 } | |
| 122 | |
| 123 protected: | |
| 124 void ReleaseBindings(); | |
| 125 | |
| 126 HRESULT StartAsyncDownload(); | |
| 127 void NotifyDelegateAndDie(); | |
| 128 void TerminateTransaction(); | |
| 129 static net::Error HresultToNetError(HRESULT hr); | |
| 130 | |
| 131 private: | |
| 132 size_t SendDataToDelegate(size_t bytes); | |
| 133 | |
| 134 // This class simplifies tracking the progress of operation. We have 3 main | |
| 135 // states: DONE, WORKING and ABORTING. | |
| 136 // When in [DONE] or [ABORTING] state, there is additional information | |
| 137 // about the result of operation. | |
| 138 // Start(), SetRedirected(), Cancel() and Done() methods trigger the state | |
| 139 // change. See comments bellow. | |
| 140 class Status { | |
| 141 public: | |
| 142 enum State {DONE, ABORTING, WORKING}; | |
| 143 struct Redirection { | |
| 144 Redirection() : http_code(0) { } | |
| 145 int http_code; | |
| 146 std::string utf8_url; | |
| 147 }; | |
| 148 | |
| 149 Status() : state_(Status::DONE) { | |
| 150 } | |
| 151 | |
| 152 State get_state() const { | |
| 153 return state_; | |
| 154 } | |
| 155 | |
| 156 // Switch from [DONE] to [WORKING]. | |
| 157 void Start() { | |
| 158 DCHECK_EQ(state_, DONE); | |
| 159 state_ = WORKING; | |
| 160 } | |
| 161 | |
| 162 // Save redirection information and switch to [ABORTING] state. | |
| 163 // Assumes binding_->Abort() will be called! | |
| 164 void SetRedirected(int http_code, const std::string& utf8_url) { | |
| 165 DCHECK_EQ(state_, WORKING); | |
| 166 DCHECK_EQ(result_.status(), net::URLRequestStatus::SUCCESS); | |
| 167 redirect_.utf8_url = utf8_url; | |
| 168 | |
| 169 // At times we receive invalid redirect codes like 0, 200, etc. We | |
| 170 // default to 302 in this case. | |
| 171 redirect_.http_code = http_code; | |
| 172 if (!net::HttpResponseHeaders::IsRedirectResponseCode(http_code)) | |
| 173 redirect_.http_code = 302; | |
| 174 | |
| 175 state_ = ABORTING; | |
| 176 } | |
| 177 | |
| 178 // Set the result as net::URLRequestStatus::CANCELED. | |
| 179 // Switch to [ABORTING] state (if not already in that state). | |
| 180 void Cancel() { | |
| 181 if (state_ == DONE) | |
| 182 return; | |
| 183 | |
| 184 if (state_ == WORKING) { | |
| 185 state_ = ABORTING; | |
| 186 } else { | |
| 187 // state_ == ABORTING | |
| 188 redirect_.http_code = 0; | |
| 189 redirect_.utf8_url.clear(); | |
| 190 } | |
| 191 | |
| 192 set_result(net::URLRequestStatus::CANCELED, 0); | |
| 193 } | |
| 194 | |
| 195 void Done() { | |
| 196 state_ = DONE; | |
| 197 } | |
| 198 | |
| 199 bool was_redirected() const { | |
| 200 return redirect_.http_code != 0; | |
| 201 } | |
| 202 | |
| 203 const Redirection& get_redirection() const { | |
| 204 return redirect_; | |
| 205 } | |
| 206 | |
| 207 const net::URLRequestStatus& get_result() const { | |
| 208 return result_; | |
| 209 } | |
| 210 | |
| 211 void set_result(net::URLRequestStatus::Status status, int error) { | |
| 212 result_.set_status(status); | |
| 213 result_.set_error(error); | |
| 214 } | |
| 215 | |
| 216 void set_result(HRESULT hr) { | |
| 217 result_.set_status(FAILED(hr)? net::URLRequestStatus::FAILED: | |
| 218 net::URLRequestStatus::SUCCESS); | |
| 219 result_.set_error(HresultToNetError(hr)); | |
| 220 } | |
| 221 | |
| 222 private: | |
| 223 Redirection redirect_; | |
| 224 State state_; | |
| 225 net::URLRequestStatus result_; | |
| 226 }; | |
| 227 | |
| 228 Status status_; | |
| 229 base::win::ScopedComPtr<IBinding> binding_; | |
| 230 base::win::ScopedComPtr<IMoniker> moniker_; | |
| 231 base::win::ScopedComPtr<IBindCtx> bind_context_; | |
| 232 base::win::ScopedComPtr<IStream> cache_; | |
| 233 base::win::ScopedComPtr<IStream> pending_data_; | |
| 234 | |
| 235 size_t pending_read_size_; | |
| 236 base::PlatformThreadId thread_; | |
| 237 HWND parent_window_; | |
| 238 bool headers_received_; | |
| 239 int calling_delegate_; // re-entrancy protection. | |
| 240 // Set to true if the ChromeFrame instance is running in privileged mode. | |
| 241 bool privileged_mode_; | |
| 242 bool pending_; | |
| 243 TerminateBindCallback terminate_bind_callback_; | |
| 244 std::string response_headers_; | |
| 245 // Defaults to true and indicates whether we want to keep the original | |
| 246 // transaction alive when we receive the last data notification from | |
| 247 // urlmon. | |
| 248 bool is_expecting_download_; | |
| 249 // Set to true if the Urlmon transaction object needs to be cleaned up | |
| 250 // when this object is destroyed. Happens if we return | |
| 251 // INET_E_TERMINATE_BIND from OnDataAvailable in the last data notification. | |
| 252 bool cleanup_transaction_; | |
| 253 // Copy of the request headers. | |
| 254 std::string request_headers_; | |
| 255 | |
| 256 DISALLOW_COPY_AND_ASSIGN(UrlmonUrlRequest); | |
| 257 }; | |
| 258 | |
| 259 #endif // CHROME_FRAME_URLMON_URL_REQUEST_PRIVATE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src