Add 'XHR' to the Resource::Type enum, and use it for XHR requests.

Source/core/fetch/ResourceLoaderOptions.h

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 52 matching lines @@
 
 // APIs like XMLHttpRequest and EventSource let the user decide
 // whether to send credentials, but they're always sent for
 // same-origin requests. Additional information is needed to handle
 // cross-origin redirects correctly.
 enum CredentialRequest {
     ClientRequestedCredentials,
     ClientDidNotRequestCredentials
 };
 
-enum MixedContentBlockingTreatment {
-    TreatAsDefaultForType,
-    TreatAsPassiveContent,
-    TreatAsActiveContent,
-    TreatAsAlwaysAllowedContent
-};
-
 enum SynchronousPolicy {
     RequestSynchronously,
     RequestAsynchronously
 };
 
 // A resource fetch can be marked as being CORS enabled. The loader
 // must perform an access check upon seeing the response.
 enum CORSEnabled {
     NotCORSEnabled,
     IsCORSEnabled
 };
 
 struct ResourceLoaderOptions {
     ResourceLoaderOptions()
         : sniffContent(DoNotSniffContent)
         , dataBufferingPolicy(BufferData)
         , allowCredentials(DoNotAllowStoredCredentials)
         , credentialsRequested(ClientDidNotRequestCredentials)
         , contentSecurityPolicyOption(CheckContentSecurityPolicy)
         , requestInitiatorContext(DocumentContext)
-        , mixedContentBlockingTreatment(TreatAsDefaultForType)
         , synchronousPolicy(RequestAsynchronously)
         , corsEnabled(NotCORSEnabled)
     {
     }
 
     ResourceLoaderOptions(
         ContentSniffingPolicy sniffContent,
         DataBufferingPolicy dataBufferingPolicy,
         StoredCredentials allowCredentials,
         CredentialRequest credentialsRequested,
         ContentSecurityPolicyCheck contentSecurityPolicyOption,
         RequestInitiatorContext requestInitiatorContext)
         : sniffContent(sniffContent)
         , dataBufferingPolicy(dataBufferingPolicy)
         , allowCredentials(allowCredentials)
         , credentialsRequested(credentialsRequested)
         , contentSecurityPolicyOption(contentSecurityPolicyOption)
         , requestInitiatorContext(requestInitiatorContext)
-        , mixedContentBlockingTreatment(TreatAsDefaultForType)
         , synchronousPolicy(RequestAsynchronously)
         , corsEnabled(NotCORSEnabled)
     {
     }
 
     // Answers the question "can a separate request with these
     // different options be re-used" (e.g. preload request)
     // The safe (but possibly slow) answer is always false.
     bool canReuseRequest(const ResourceLoaderOptions& other) const
     {
         // sniffContent is dead code.
         // dataBufferingPolicy differences are believed to be safe for re-use.
         // FIXME: check allowCredentials.
         // FIXME: check credentialsRequested.
         // FIXME: check contentSecurityPolicyOption.
         // initiatorInfo is purely informational and should be benign for re-use.
         // requestInitiatorContext is benign (indicates document vs. worker)
-        // FIXME: check mixedContentBlockingTreatment.
         // synchronousPolicy (safe to re-use an async XHR response for sync, etc.)
         return corsEnabled == other.corsEnabled;
         // securityOrigin has more complicated checks which callers are responsible for.
     }
 
     ContentSniffingPolicy sniffContent; // FIXME: Dead code, please remove.
     DataBufferingPolicy dataBufferingPolicy;
     StoredCredentials allowCredentials; // Whether HTTP credentials and cookies are sent with the request.
     CredentialRequest credentialsRequested; // Whether the client (e.g. XHR) wanted credentials in the first place.
     ContentSecurityPolicyCheck contentSecurityPolicyOption;
     FetchInitiatorInfo initiatorInfo;
     RequestInitiatorContext requestInitiatorContext;
-    MixedContentBlockingTreatment mixedContentBlockingTreatment;
     SynchronousPolicy synchronousPolicy;
     CORSEnabled corsEnabled; // If the resource is loaded out-of-origin, whether or not to use CORS.
     RefPtr<SecurityOrigin> securityOrigin;
 };
 
 } // namespace WebCore
 
 #endif // ResourceLoaderOptions_h