blob: 634110514854b20ed0616a0ddd7153f10442af97 [file] [log] [blame]
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <windows.h>
#include <wininet.h>
#include "base/lock.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_job.h"
namespace net {
class AuthData;
class MessageLoop;
// For all WinInet-based URL requests
class URLRequestInetJob : public URLRequestJob {
URLRequestInetJob(URLRequest* request);
virtual ~URLRequestInetJob();
virtual void SetExtraRequestHeaders(const std::string& headers) {
extra_request_headers_ = headers;
virtual void Kill();
virtual bool ReadRawData(char* buf, int buf_size, int *bytes_read);
// URLRequestJob Authentication methods
virtual void SetAuth(const std::wstring& username,
const std::wstring& password);
virtual void CancelAuth();
// A structure holding the result and error code of an asynchronous IO.
// This is a copy of INTERNET_ASYNC_RESULT.
struct AsyncResult {
DWORD_PTR dwResult;
DWORD dwError;
// A virtual method to handle WinInet callbacks. If this class
// issues asynchronous IO, it will need to override this method
// to receive completions of those asynchronous IOs. The class
// must track whether it has an async IO outstanding, and if it
// does not it must call the base class' OnIOComplete.
virtual void OnIOComplete(const AsyncResult& result) = 0;
// Used internally to setup the OnIOComplete call. Public because this
// is called from the Windows procedure, and we don't want to make it a
// friend so we can avoid the Windows headers for this header file.
void CallOnIOComplete(const AsyncResult& result);
HINTERNET request_handle() const { return request_handle_; }
// Called by this class and subclasses to send or resend this request.
virtual void SendRequest() = 0;
// Calls InternetReadFile(Ex) depending on the derived class.
// Returns ERROR_SUCCESS on success, or else a standard Windows error code
// on failure (from GetLastError()).
virtual int CallInternetRead(char* dest, int dest_size, int *bytes_read) = 0;
// After the base class calls CallInternetRead and the result is available,
// it will call this method to get the number of received bytes.
virtual bool GetReadBytes(const AsyncResult& result, int* bytes_read) = 0;
// Called by this class and subclasses whenever a WinInet call fails. This
// method returns true if the error just means that we have to wait for
// OnIOComplete to be called.
bool ProcessRequestError(int error);
// Called by URLRequestJob to get more data from the data stream of this job.
virtual bool GetMoreData();
// Cleans up the connection, if necessary, and closes the connection and
// request handles. May be called multiple times, it will be a NOP if
// there is nothing to do.
void CleanupConnection();
// Closes the given handle.
void CleanupHandle(HINTERNET handle);
// Returns the global handle to the internet (NOT the same as the connection
// or request handle below)
static HINTERNET GetTheInternet();
// Makes appropriate asynch call to re-send a request based on
// dynamic scheme type and user action at authentication prompt
//(OK or Cancel)
virtual void OnCancelAuth() = 0;
virtual void OnSetAuth() = 0;
// Handle of the connection for this request. This handle is created
// by subclasses that create the connection according to their requirements.
// It will be automatically destroyed by this class when the connection is
// being closed. See also 'request_handle_'
HINTERNET connection_handle_;
// Handle of the specific request created by subclasses to meet their own
// requirements. This handle has a more narrow scope than the connection
// handle. If non-null, it will be automatically destroyed by this class
// when the connection is being closed. It will be destroyed before the
// connection handle.
HINTERNET request_handle_;
// The last error that occurred. Used by ContinueDespiteLastError to adjust
// the request's load_flags to ignore this error.
DWORD last_error_;
// Any extra request headers (\n-delimited) that should be included in the
// request.
std::string extra_request_headers_;
// Authentication information.
scoped_refptr<net::AuthData> proxy_auth_;
scoped_refptr<net::AuthData> server_auth_;
// One-time global state setup
static void InitializeTheInternet(const std::string& user_agent);
// Runs on some background thread (called by WinInet)
static void CALLBACK URLRequestStatusCallback(HINTERNET handle,
DWORD_PTR job_id,
DWORD status,
LPVOID status_info,
DWORD status_info_len);
static HINTERNET the_internet_;
#ifndef NDEBUG
static MessageLoop* my_message_loop_; // Used to sanity-check that all
// requests are made on the same
// thread
// true if waiting for OnIOComplete to be called
bool is_waiting_;
// debugging state - is there a read already in progress
bool read_in_progress_;
// The result and error code of asynchronous IO. It is modified by the
// status callback functions on asynchronous IO completion and passed to
// CallOnIOComplete. Since there is at most one pending IO, the object
// can reuse the async_result_ member for all its asynchronous IOs.
AsyncResult async_result_;
Lock loop_lock_;
MessageLoop* loop_;