private HttpRequestMessage CreateHttpRequest(Request request, IAuthenticator authenticator)
        {
            var httpRequest = new HttpRequestMessage(request.Method, new Uri(request.Uri));

            if (request.Method == HttpMethod.Post || request.Method == HttpMethod.Put)
            {
                var contentRequest = request as ContentRequest;

                if (contentRequest != null && !string.IsNullOrEmpty(contentRequest.Content) && contentRequest.Encoding != null && !string.IsNullOrEmpty(contentRequest.MediaType))
                {
                    httpRequest.Content = new StringContent(contentRequest.Content, contentRequest.Encoding, contentRequest.MediaType);
                }
            }

            var headers = MergeHeaders(request.Headers, authenticator != null ? authenticator.GetHeaders(request) : null);

            if (headers != null && headers.Count > 0)
            {
                foreach (var header in headers)
                {
                    httpRequest.Headers.Add(header.Key, header.Value);
                }
            }

            return httpRequest;
        }

 /// <summary>
 /// Download a file and return a string with its content.
 /// </summary>
 /// <param name="authenticator">
 /// Authenticator responsible for creating authorized web requests.
 /// </param>
 /// <param name="file">Drive File instance.</param>
 /// <returns>File's content if successful, null otherwise.</returns>
 public static System.IO.Stream DownloadFile(
     IAuthenticator authenticator, File file)
 {
     if (!String.IsNullOrEmpty(file.DownloadUrl))
     {
         try
         {
             HttpWebRequest request = (HttpWebRequest)WebRequest.Create(
                 new Uri(file.DownloadUrl));
             authenticator.ApplyAuthenticationToRequest(request);
             HttpWebResponse response = (HttpWebResponse)request.GetResponse();
             if (response.StatusCode == HttpStatusCode.OK)
             {
                 return response.GetResponseStream();
             }
             else
             {
                 Console.WriteLine(
                     "An error occurred: " + response.StatusDescription);
                 return null;
             }
         }
         catch (Exception e)
         {
             Console.WriteLine("An error occurred: " + e.Message);
             return null;
         }
     }
     else
     {
         // The file doesn't have any content stored on Drive.
         return null;
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AuthenticationModule" /> class.
 /// </summary>
 /// <param name="authenticator">Used for the actual authentication.</param>
 /// <param name="principalFactory">Used to create the principal that should be used.</param>
 /// <exception cref="System.ArgumentNullException">autheonticator</exception>
 public AuthenticationModule(IAuthenticator authenticator, IPrincipalFactory principalFactory)
 {
     if (authenticator == null) throw new ArgumentNullException("authenticator");
     if (principalFactory == null) throw new ArgumentNullException("principalFactory");
     _authenticator = authenticator;
     _principalFactory = principalFactory;
 }

	    /// <summary>
        /// Initializes a new instance of the <see cref="DefaultHttpPostClient"/> class.
        /// </summary>
        /// <param name="hostProvider">Instance of IHostProvider. If not specified, default one will be used.</param>
        /// <param name="auth">Instance of IAuthenticator. If not specified request will not use authentication.</param>
        public DefaultHttpPostClient([CanBeNull] IHostProvider hostProvider, [CanBeNull] IAuthenticator auth)
        {
            _hostProvider = hostProvider ?? new DefaultHostsProvider();
            _authenticator = auth;

            Init();
        }

 public RequestRunner(
     ITransmissionSettings transmissionSettings,
     IAuthenticator authenticator)
 {
     this.transmissionSettings = transmissionSettings;
     this.authenticator = authenticator;
 }

        internal static AuthenticationHeaderValue GetAuthenticationHeaderValue(IAuthenticator authenticator, Uri uri)
        {
            AuthenticationHeaderValue authHeader = null;

            var userInfo = uri != null ? uri.UserInfo : null;
            if (!String.IsNullOrEmpty(userInfo)) 
            {
                authHeader = uri.GetAuthenticationHeader("Basic");
                if (authHeader == null)
                {
                    Log.W(Tag, "Unable to parse user info, not setting credentials");
                }
            } 
            else 
            {
                if (authenticator != null) 
                {
                    userInfo = authenticator.UserInfo;
                    var scheme = authenticator.Scheme;
                    if (userInfo != null && scheme != null)
                    {
                        authHeader = userInfo.AsAuthenticationHeader(scheme);
                    }
                }
            }

            return authHeader;
        }

        private void Init(IAuthenticator auth, string server)
        {
            Server = server;

            RestClient = new RestClient(Server);
            RestClient.Authenticator = auth;
        }

        /// <summary>
        /// Initializes a new instance of the Yandex.Money.Api.Sdk.Interfaces.IHttpClient interface.
        /// </summary>
        /// <param name="hostProvider">an instance of IHostProvider implementation</param>
        /// <param name="auth">an instance of IAuthenticator implementation</param>
        public DefaultHttpPostClient(IHostProvider hostProvider, IAuthenticator auth)
        {
            _hostProvider = hostProvider;
            _authenticator = auth;

            Init();
        }

 /// <summary>
 /// Initializes a new instance of the AuthenticatorConfiguration class.
 /// </summary>
 public AuthenticatorConfiguration(string name, IAuthenticator authenticator, IPrincipalBuilder principalBuilder)
 {
     //TODO: 4-8-2011 -- create a FleutnValidator that matches up with this and call it here
     Name = name;
     Authenticator = authenticator;
     PrincipalBuilder = principalBuilder;
 }

        public WelcomeViewModel(IAuthenticator authenticator, ITokenProvider tokenProvider)
        {
            _authenticator = authenticator;
            _tokenProvider = tokenProvider;

            LoginCommand = new Command(ExecuteLoginCommand);

        }

 /// <summary>
 /// Initializes a new instance of the DigestAuthenticatorConfiguration class.
 /// </summary>
 public DigestAuthenticatorConfiguration(string name, IAuthenticator authenticator,
     IPrincipalBuilder principalBuilder, string realm, string privateKey)
     : base(name, authenticator, principalBuilder)
 {
     //TODO: 4-8-2011 cook up an AbstractValidator class that verifies this goop
     Realm = realm;
     PrivateKey = privateKey;
 }

 public LoginController(IAuthenticator authenticator, IAccountRepository accountRepository, IEventBus eventBus,
                        IFacebookDataRepository facebookDataRepository)
 {
     this.authenticator = authenticator;
     this.accountRepository = accountRepository;
     this.eventBus = eventBus;
     this.facebookDataRepository = facebookDataRepository;
 }

 public Client(IAuthenticator authenticator)
 {
     _restClient = new RestClient(StravaClient.ApiBaseUrl) { Authenticator = authenticator };
     Athletes = new AthleteClient(this);
     Activities = new ActivityClient(this);
     Segments = new SegmentClient(this);
     Clubs = new ClubClient(this);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AccountController"/> class.
 /// </summary>
 /// <param name="userSession">The user session.</param>
 /// <param name="memberService">The user repository.</param>
 /// <param name="authenticator">The authenticator.</param>
 /// <param name="cryptographer">The cryptographer.</param>
 /// <param name="authenticationService"></param>
 public AccountController(IUserSession userSession, IMemberService memberService, IAuthenticator authenticator, ICryptographer cryptographer, IAuthenticationService authenticationService)
     : base(userSession)
 {
     this.memberService = memberService;
     this.authenticator = authenticator;
     this.cryptographer = cryptographer;
     this.authenticationService = authenticationService;
 }

        public UserController(
			IAuthenticator authenticator,
			IDocumentSession session,
			IExecutionContext executionContext)
        {
            _authenticator = authenticator;
            _session = session;
            _executionContext = executionContext;
        }

        /// <inheritdoc/>
        /// <summary>
        /// Initializes a new instance of the <see cref="AuthClient"/> class and binds it with a network session.
        /// </summary>
        /// <param name="authenticator">The <see cref="IAuthenticator"/> to use for authenticating the user.</param>
        /// <param name="nexus">The <see cref="IAuthToNexusRequestHandler"/> to query for... world stuff.</param>
        /// <param name="serverSession"><inheritdoc/></param>
        /// <param name="packetFactory"><inheritdoc/></param>
        /// <param name="logger"><inheritdoc/></param>
        public AuthClient(IAuthenticator authenticator, IAuthToNexusRequestHandler nexus, IServerSession serverSession, IPacketFactory packetFactory, ILogger logger)
            : base(serverSession, packetFactory, logger)
        {
            this.authenticator = authenticator;
            this.nexus = nexus;

            this.LoginAttempts = 0;
            this.State = AuthClientState.NotLoggedIn;
        }

 public RequestRunner(
     ITransmissionSettings transmissionSettings,
     IWebRequestGateway webRequestGateway,
     IAuthenticator authenticator)
 {
     this.transmissionSettings = transmissionSettings;
     this.webRequestGateway = webRequestGateway;
     this.authenticator = authenticator;
 }

        public AuthenticationController(IApplicationServices applicationServices, IFormsAuthentication formsAuthentication, IAuthenticator authenticator)
            : base(applicationServices)
        {
            Guard.IsNotNull(formsAuthentication, "formsAuthentication");
            Guard.IsNotNull(authenticator, "authenticator");

            this.formsAuthentication = formsAuthentication;
            this.authenticator = authenticator;
        }

 public AuthTicketService(
     [NotNull]HttpContextBase httpContext,
     [NotNull]IAuthTicketFactory ticketFactory,
     [NotNull]IAuthenticator authenticator)
 {
     this.httpContext = httpContext;
     this.ticketFactory = ticketFactory;
     this.authenticator = authenticator;
 }

        public LogWriter(ILogContext context, IAuthenticator authenticator, IClock clock)
        {
            Contract.Requires<ArgumentNullException>(context != null);
            Contract.Requires<ArgumentNullException>(authenticator != null);
            Contract.Requires<ArgumentNullException>(clock != null);

            _context = context;
            _authenticator = authenticator;
            _clock = clock;
        }