Changeset 171801 in webkit


Ignore:
Timestamp:
Jul 30, 2014 11:56:13 AM (10 years ago)
Author:
mitz@apple.com
Message:

Source/WebCore: Made Credential hold onto an NSURLCredential when needed.
Work towards fixing ​https://bugs.webkit.org/show_bug.cgi?id=135327

Reviewed by Alexey Proskuryakov.

No change in functionality.

  • WebCore.exp.in: Updated.
  • platform/network/Credential.h: Removed definition of CERTIFICATE_CREDENTIALS_SUPPORTED,

which is not used anymore.

  • platform/network/CredentialBase.h:

(WebCore::CredentialBase::encodingRequiresPlatformData): Added a base implementation that
returns false.

  • platform/network/cf/AuthenticationCF.cpp:

Changed to use the Credential constructor that takes an CFURLCredential, and the new
cfCredential member function. Made the createCF and core functions Windows-only and
therefore removed the CERTIFICATE_CREDENTIALS_SUPPORTED code from them.

  • platform/network/cf/AuthenticationCF.h:
  • platform/network/cf/CredentialStorageCFNet.cpp:

(WebCore::CredentialStorage::getFromPersistentStorage): Changed to construct a Credential
from a CFURLCredential.
(WebCore::CredentialStorage::saveToPersistentStorage): Changed to use the new cfCredential
member function.

  • platform/network/cf/ResourceHandleCFNet.cpp:

(WebCore::ResourceHandle::didReceiveAuthenticationChallenge): Ditto to both.
(WebCore::ResourceHandle::receivedCredential): Ditto.

  • platform/network/cocoa/CredentialCocoa.h:

Replaced the m_identity, m_certificates and m_type member variables with an m_nsCredential
one holding onto an NSURLCredential. Declared constructors from and getters for
NSURLCredential and CFURLCredentialRef.
(WebCore::Credential::encodingRequiresPlatformData): Override that checks the
NSURLCredential if necessary.

  • platform/network/cocoa/CredentialCocoa.mm:

(WebCore::toNSURLCredentialPersistence): New helper function.
(WebCore::toCredentialPersistence): Ditto.
(WebCore::Credential::Credential): Defined constructors to create or take an
NSURLCredential.
(WebCore::Credential::cfCredential): Added.
(WebCore::Credential::nsCredential): Added. Returns nil for the empty credential.
(WebCore::Credential::isEmpty): Changed to check m_nsCredential.
(WebCore::Credential::platformCompare): Changed to compare m_nsCredential if needed.
(WebCore::Credential::encodingRequiresPlatformData): Returns true if the credential is not
a user and a password.

  • platform/network/mac/AuthenticationMac.h: Removed mac and core functions for Credential.
  • platform/network/mac/AuthenticationMac.mm:

(-[WebCoreAuthenticationClientAsChallengeSender useCredential:forAuthenticationChallenge:]):
Changed to use Credential constructor that takes an NSURLCredential.
(WebCore::AuthenticationChallenge::AuthenticationChallenge): Ditto. Also use the
nsCredential getter.

  • platform/network/mac/CredentialStorageMac.mm:

(WebCore::CredentialStorage::getFromPersistentStorage): Use new Credential constructor.

  • platform/network/mac/ResourceHandleMac.mm:

(WebCore::ResourceHandle::didReceiveAuthenticationChallenge): Ditto. Also use the
nsCredential getter.
(WebCore::ResourceHandle::receivedCredential): Ditto.

Source/WebKit/mac: Updated for changes to the WebCore::Credential API.
Work towards fixing ​https://bugs.webkit.org/show_bug.cgi?id=135327

Reviewed by Alexey Proskuryakov.

  • Misc/WebDownload.mm:

(-[WebDownloadInternal download:didReceiveAuthenticationChallenge:]): Use new nsCredential
getter.

  • Plugins/WebBaseNetscapePluginView.mm:

(WebKit::getAuthenticationInfo): Ditto.

Source/WebKit2: Updated for changes to the WebCore::Credential API.
Work towards fixing ​https://bugs.webkit.org/show_bug.cgi?id=135327

Reviewed by Alexey Proskuryakov.

  • Shared/Downloads/mac/DownloadMac.mm:

(WebKit::Download::receivedCredential):Use new Credential::nsCredential getter.

  • Shared/WebCoreArgumentCoders.cpp:

(IPC::ArgumentCoder<Credential>::encode): If encoding the credential requires encoding the
platform data, do that.
(IPC::ArgumentCoder<Credential>::decode): If platform data was encoded, decode it.

  • Shared/WebCoreArgumentCoders.h:
  • Shared/mac/WebCoreArgumentCodersMac.mm:

(IPC::ArgumentCoder<Credential>::encodePlatformData): Archive the NSURLCredential.
(IPC::ArgumentCoder<Credential>::decodePlatformData): Unarchive it.

  • UIProcess/API/Cocoa/WKNSURLAuthenticationChallenge.mm:

(-[WKNSURLAuthenticationChallengeSender useCredential:forAuthenticationChallenge:]): Use
Credential constructor that takes an NSURLCredential.

  • UIProcess/Cocoa/NavigationState.mm:

(WebKit::NavigationState::LoaderClient::didReceiveAuthenticationChallengeInFrame): Ditto.

Location:
trunk/Source
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r171799 r171801  
     12014-07-30  Dan Bernstein  <mitz@apple.com>
     2
     3        Made Credential hold onto an NSURLCredential when needed.
     4        Work towards fixing https://bugs.webkit.org/show_bug.cgi?id=135327
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        No change in functionality.
     9
     10        * WebCore.exp.in: Updated.
     11
     12        * platform/network/Credential.h: Removed definition of CERTIFICATE_CREDENTIALS_SUPPORTED,
     13        which is not used anymore.
     14
     15        * platform/network/CredentialBase.h:
     16        (WebCore::CredentialBase::encodingRequiresPlatformData): Added a base implementation that
     17        returns false.
     18
     19        * platform/network/cf/AuthenticationCF.cpp:
     20        Changed to use the Credential constructor that takes an CFURLCredential, and the new
     21        cfCredential member function. Made the createCF and core functions Windows-only and
     22        therefore removed the CERTIFICATE_CREDENTIALS_SUPPORTED code from them.
     23        * platform/network/cf/AuthenticationCF.h:
     24
     25        * platform/network/cf/CredentialStorageCFNet.cpp:
     26        (WebCore::CredentialStorage::getFromPersistentStorage): Changed to construct a Credential
     27        from a CFURLCredential.
     28        (WebCore::CredentialStorage::saveToPersistentStorage): Changed to use the new cfCredential
     29        member function.
     30
     31        * platform/network/cf/ResourceHandleCFNet.cpp:
     32        (WebCore::ResourceHandle::didReceiveAuthenticationChallenge): Ditto to both.
     33        (WebCore::ResourceHandle::receivedCredential): Ditto.
     34
     35        * platform/network/cocoa/CredentialCocoa.h:
     36        Replaced the m_identity, m_certificates and m_type member variables with an m_nsCredential
     37        one holding onto an NSURLCredential. Declared constructors from and getters for
     38        NSURLCredential and CFURLCredentialRef.
     39        (WebCore::Credential::encodingRequiresPlatformData): Override that checks the
     40        NSURLCredential if necessary.
     41
     42        * platform/network/cocoa/CredentialCocoa.mm:
     43        (WebCore::toNSURLCredentialPersistence): New helper function.
     44        (WebCore::toCredentialPersistence): Ditto.
     45        (WebCore::Credential::Credential): Defined constructors to create or take an
     46        NSURLCredential.
     47        (WebCore::Credential::cfCredential): Added.
     48        (WebCore::Credential::nsCredential): Added. Returns nil for the empty credential.
     49        (WebCore::Credential::isEmpty): Changed to check m_nsCredential.
     50        (WebCore::Credential::platformCompare): Changed to compare m_nsCredential if needed.
     51        (WebCore::Credential::encodingRequiresPlatformData): Returns true if the credential is not
     52        a user and a password.
     53
     54        * platform/network/mac/AuthenticationMac.h: Removed mac and core functions for Credential.
     55        * platform/network/mac/AuthenticationMac.mm:
     56        (-[WebCoreAuthenticationClientAsChallengeSender useCredential:forAuthenticationChallenge:]):
     57        Changed to use Credential constructor that takes an NSURLCredential.
     58        (WebCore::AuthenticationChallenge::AuthenticationChallenge): Ditto. Also use the
     59        nsCredential getter.
     60
     61        * platform/network/mac/CredentialStorageMac.mm:
     62        (WebCore::CredentialStorage::getFromPersistentStorage): Use new Credential constructor.
     63
     64        * platform/network/mac/ResourceHandleMac.mm:
     65        (WebCore::ResourceHandle::didReceiveAuthenticationChallenge): Ditto. Also use the
     66        nsCredential getter.
     67        (WebCore::ResourceHandle::receivedCredential): Ditto.
     68
    1692014-07-30  Sergio Villar Senin  <svillar@igalia.com>
    270

  • trunk/Source/WebCore/WebCore.exp.in

    r171749 r171801  
    7272__ZN7WebCore10ClientRectC1ERKNS_9FloatRectE
    7373__ZN7WebCore10ClientRectC1Ev
     74__ZN7WebCore10Credential28encodingRequiresPlatformDataEP15NSURLCredential
     75__ZN7WebCore10CredentialC1EP15NSURLCredential
    7476__ZN7WebCore10FloatPointC1ERK7CGPoint
    7577__ZN7WebCore10FloatPointC1ERKNS_8IntPointE
    … …  
    10731075__ZN7WebCore3URLC1EPK7__CFURL
    10741076__ZN7WebCore3URLC1ERKS0_RKN3WTF6StringE
    1075 __ZN7WebCore3macERKNS_10CredentialE
    10761077__ZN7WebCore3macERKNS_23AuthenticationChallengeE
    10771078__ZN7WebCore40restrictMinimumScaleFactorToViewportSizeERNS_18ViewportAttributesENS_7IntSizeEf
    … …  
    11501151__ZN7WebCore4PathC1Ev
    11511152__ZN7WebCore4PathD1Ev
    1152 __ZN7WebCore4coreEP15NSURLCredential
    11531153__ZN7WebCore4coreEP28NSURLAuthenticationChallenge
    11541154__ZN7WebCore4toJSEPN3JSC9ExecStateEPNS_17JSDOMGlobalObjectEPNS0_7ProfileE
    … …  
    15371537__ZNK3JSC8Bindings10RootObject12globalObjectEv
    15381538__ZNK3WTF6String14createCFStringEv
    1539 __ZNK7WebCore10Credential12certificatesEv
    1540 __ZNK7WebCore10Credential4typeEv
     1539__ZNK7WebCore10Credential12nsCredentialEv
    15411540__ZNK7WebCore10Credential7isEmptyEv
    1542 __ZNK7WebCore10Credential8identityEv
    15431541__ZNK7WebCore10FloatPointcv7CGPointEv
    15441542__ZNK7WebCore10FontGlyphs17realizeFontDataAtERKNS_15FontDescriptionEj
    … …  
    22222220.objc_class_name_WebWindowFadeAnimation
    22232221.objc_class_name_WebWindowScaleAnimation
    2224 __ZN7WebCore10CredentialC1EP20OpaqueSecIdentityRefPK9__CFArrayNS_21CredentialPersistenceE
    22252222__ZN7WebCore10FloatPointC1ERK8_NSPoint
    22262223__ZN7WebCore10handCursorEv
    … …  
    25282525_WebUIApplicationWillEnterForegroundNotification
    25292526_WebUIApplicationWillResignActiveNotification
    2530 __ZN7WebCore10CredentialC1EP13__SecIdentityPK9__CFArrayNS_21CredentialPersistenceE
    25312527__ZN7WebCore10RenderView35resumePausedImageAnimationsIfNeededEv
    25322528__ZN7WebCore10ScrollView15setScrollOffsetERKNS_8IntPointE

  • trunk/Source/WebCore/platform/network/Credential.h

    r171747 r171801  
    3333#include "CredentialBase.h"
    3434
    35 // FIXME: Remove this macro once it is not used in WebKit.
    36 #define CERTIFICATE_CREDENTIALS_SUPPORTED 0
    37 
    3835namespace WebCore {
    3936

  • trunk/Source/WebCore/platform/network/CredentialBase.h

    r171747 r171801  
    4848    bool hasPassword() const;
    4949    CredentialPersistence persistence() const;
    50    
     50
     51    bool encodingRequiresPlatformData() const { return false; }
     52
    5153    static bool compare(const Credential&, const Credential&);
    5254

  • trunk/Source/WebCore/platform/network/cf/AuthenticationCF.cpp

    r171554 r171801  
    5656#if PLATFORM(COCOA)
    5757    : AuthenticationChallengeBase(ProtectionSpace(CFURLAuthChallengeGetProtectionSpace(cfChallenge)),
     58                                  Credential(CFURLAuthChallengeGetProposedCredential(cfChallenge)),
    5859#else
    5960    : AuthenticationChallengeBase(core(CFURLAuthChallengeGetProtectionSpace(cfChallenge)),
    60 #endif
    6161                                  core(CFURLAuthChallengeGetProposedCredential(cfChallenge)),
     62#endif
    6263                                  CFURLAuthChallengeGetPreviousFailureCount(cfChallenge),
    6364                                  (CFURLResponseRef)CFURLAuthChallengeGetFailureResponse(cfChallenge),
    … …  
    9394    // FIXME: Why not cache CFURLAuthChallengeRef in m_cfChallenge? Foundation counterpart does that.
    9495
    95     CFURLCredentialRef credential = createCF(coreChallenge.proposedCredential());
    96    
    9796#if PLATFORM(COCOA)
    98     CFURLAuthChallengeRef result = CFURLAuthChallengeCreate(0, coreChallenge.protectionSpace().cfSpace(), credential,
     97    CFURLAuthChallengeRef result = CFURLAuthChallengeCreate(0, coreChallenge.protectionSpace().cfSpace(), coreChallenge.proposedCredential().cfCredential(),
    9998#else
     99    RetainPtr<CFURLCredentialRef> credential = adoptCF(createCF(coreChallenge.proposedCredential()));
    100100    RetainPtr<CFURLProtectionSpaceRef> protectionSpace = adoptCF(createCF(coreChallenge.protectionSpace()));
    101101
    102     CFURLAuthChallengeRef result = CFURLAuthChallengeCreate(0, protectionSpace.get(), credential,
     102    CFURLAuthChallengeRef result = CFURLAuthChallengeCreate(0, protectionSpace.get(), credential.get(),
    103103#endif
    104104                                        coreChallenge.previousFailureCount(),
    105105                                        coreChallenge.failureResponse().cfURLResponse(),
    106106                                        coreChallenge.error());
    107     CFRelease(credential);
    108107    return result;
    109108}
     109
     110#if PLATFORM(WIN)
    110111
    111112CFURLCredentialRef createCF(const Credential& coreCredential)
    … …  
    125126    }
    126127   
    127 #if CERTIFICATE_CREDENTIALS_SUPPORTED
    128     if (coreCredential.type() == CredentialTypeClientCertificate)
    129         return CFURLCredentialCreateWithIdentityAndCertificateArray(kCFAllocatorDefault, coreCredential.identity(), coreCredential.certificates(), persistence);
    130 #endif
    131 
    132128    return CFURLCredentialCreate(0, coreCredential.user().createCFString().get(), coreCredential.password().createCFString().get(), 0, persistence);
    133129}
    134130
    135 #if PLATFORM(WIN)
    136131CFURLProtectionSpaceRef createCF(const ProtectionSpace& coreSpace)
    137132{
    … …  
    200195    return CFURLProtectionSpaceCreate(0, coreSpace.host().createCFString().get(), coreSpace.port(), serverType, coreSpace.realm().createCFString().get(), scheme);
    201196}
    202 #endif // PLATFORM(WIN)
    203197
    204198Credential core(CFURLCredentialRef cfCredential)
    … …  
    221215    }
    222216
    223 #if CERTIFICATE_CREDENTIALS_SUPPORTED
    224     SecIdentityRef identity = CFURLCredentialGetCertificateIdentity(cfCredential);
    225     if (identity)
    226         return Credential(identity, CFURLCredentialGetCertificateArray(cfCredential), persistence);
    227 #endif
    228 
    229217    RetainPtr<CFStringRef> password = adoptCF(CFURLCredentialCopyPassword(cfCredential));
    230218    return Credential(CFURLCredentialGetUsername(cfCredential), password.get(), persistence);
    231219}
    232220
    233 #if PLATFORM(WIN)
    234221ProtectionSpace core(CFURLProtectionSpaceRef cfSpace)
    235222{

  • trunk/Source/WebCore/platform/network/cf/AuthenticationCF.h

    r171540 r171801  
    4141
    4242CFURLAuthChallengeRef createCF(const AuthenticationChallenge&);
     43#if PLATFORM(WIN)
    4344CFURLCredentialRef createCF(const Credential&);
    44 #if PLATFORM(WIN)
    4545CFURLProtectionSpaceRef createCF(const ProtectionSpace&);
    4646#endif
    … …  
    4949AuthenticationChallenge core(CFURLAuthChallengeRef);
    5050#endif
     51#if PLATFORM(WIN)
    5152Credential core(CFURLCredentialRef);
    52 #if PLATFORM(WIN)
    5353ProtectionSpace core(CFURLProtectionSpaceRef);
    5454#endif

  • trunk/Source/WebCore/platform/network/cf/CredentialStorageCFNet.cpp

    r171545 r171801  
    5050#if PLATFORM(COCOA)
    5151    RetainPtr<CFURLCredentialRef> credentialCF = adoptCF(wkCopyCredentialFromCFPersistentStorage(protectionSpace.cfSpace()));
     52    return Credential(credentialCF.get());
    5253#else
    5354    RetainPtr<CFURLProtectionSpaceRef> protectionSpaceCF = adoptCF(createCF(protectionSpace));
    5455    RetainPtr<CFURLCredentialRef> credentialCF = adoptCF(wkCopyCredentialFromCFPersistentStorage(protectionSpaceCF.get()));
     56    return core(credentialCF.get());
    5557#endif
    56     return core(credentialCF.get());
    5758}
    5859
    … …  
    6465    if (credential.persistence() == CredentialPersistenceNone) {
    6566        Credential sessionCredential(credential, CredentialPersistenceForSession);
    66         RetainPtr<CFURLCredentialRef> sessionCredentialCF = adoptCF(createCF(sessionCredential));
    67         CFURLCredentialStorageSetDefaultCredentialForProtectionSpace(storageCF.get(), sessionCredentialCF.get(), protectionSpace.cfSpace());
    68     } else {
    69         RetainPtr<CFURLCredentialRef> credentialCF = adoptCF(createCF(credential));
    70         CFURLCredentialStorageSetDefaultCredentialForProtectionSpace(storageCF.get(), credentialCF.get(), protectionSpace.cfSpace());
    71     }
     67        CFURLCredentialStorageSetDefaultCredentialForProtectionSpace(storageCF.get(), sessionCredential.cfCredential(), protectionSpace.cfSpace());
     68    } else
     69        CFURLCredentialStorageSetDefaultCredentialForProtectionSpace(storageCF.get(), credential.cfCredential(), protectionSpace.cfSpace());
    7270}
    7371#endif

  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFNet.cpp

    r170930 r171801  
    343343
    344344    if (!d->m_user.isNull() && !d->m_pass.isNull()) {
    345         RetainPtr<CFURLCredentialRef> credential = adoptCF(CFURLCredentialCreate(kCFAllocatorDefault, d->m_user.createCFString().get(), d->m_pass.createCFString().get(), 0, kCFURLCredentialPersistenceNone));
     345        RetainPtr<CFURLCredentialRef> cfCredential = adoptCF(CFURLCredentialCreate(kCFAllocatorDefault, d->m_user.createCFString().get(), d->m_pass.createCFString().get(), 0, kCFURLCredentialPersistenceNone));
     346#if PLATFORM(COCOA)
     347        Credential credential = Credential(cfCredential.get());
     348#else
     349        Credential credential = core(cfCredential.get());
     350#endif
    346351       
    347352        URL urlToStore;
    348353        if (challenge.failureResponse().httpStatusCode() == 401)
    349354            urlToStore = challenge.failureResponse().url();
    350         CredentialStorage::set(core(credential.get()), challenge.protectionSpace(), urlToStore);
     355        CredentialStorage::set(credential, challenge.protectionSpace(), urlToStore);
    351356       
    352         CFURLConnectionUseCredential(d->m_connection.get(), credential.get(), challenge.cfURLAuthChallengeRef());
     357        CFURLConnectionUseCredential(d->m_connection.get(), cfCredential.get(), challenge.cfURLAuthChallengeRef());
    353358        d->m_user = String();
    354359        d->m_pass = String();
    … …  
    373378                    CredentialStorage::set(credential, challenge.protectionSpace(), challenge.failureResponse().url());
    374379                }
     380#if PLATFORM(COCOA)
     381                CFURLConnectionUseCredential(d->m_connection.get(), credential.cfCredential(), challenge.cfURLAuthChallengeRef());
     382#else
    375383                RetainPtr<CFURLCredentialRef> cfCredential = adoptCF(createCF(credential));
    376384                CFURLConnectionUseCredential(d->m_connection.get(), cfCredential.get(), challenge.cfURLAuthChallengeRef());
     385#endif
    377386                return;
    378387            }
    … …  
    417426        // to ignore it for a particular request (short of removing it altogether).
    418427        Credential webCredential(credential.user(), credential.password(), CredentialPersistenceNone);
    419         RetainPtr<CFURLCredentialRef> cfCredential = adoptCF(createCF(webCredential));
    420        
     428
    421429        URL urlToStore;
    422430        if (challenge.failureResponse().httpStatusCode() == 401)
    … …  
    424432        CredentialStorage::set(webCredential, challenge.protectionSpace(), urlToStore);
    425433
     434#if PLATFORM(COCOA)
     435        CFURLConnectionUseCredential(d->m_connection.get(), webCredential.cfCredential(), challenge.cfURLAuthChallengeRef());
     436#else
     437        RetainPtr<CFURLCredentialRef> cfCredential = adoptCF(createCF(webCredential));
    426438        CFURLConnectionUseCredential(d->m_connection.get(), cfCredential.get(), challenge.cfURLAuthChallengeRef());
     439#endif
    427440    } else {
     441#if PLATFORM(COCOA)
     442        CFURLConnectionUseCredential(d->m_connection.get(), credential.cfCredential(), challenge.cfURLAuthChallengeRef());
     443#else
    428444        RetainPtr<CFURLCredentialRef> cfCredential = adoptCF(createCF(credential));
    429445        CFURLConnectionUseCredential(d->m_connection.get(), cfCredential.get(), challenge.cfURLAuthChallengeRef());
     446#endif
    430447    }
    431448

  • trunk/Source/WebCore/platform/network/cocoa/CredentialCocoa.h

    r171747 r171801  
    3131#include <wtf/RetainPtr.h>
    3232
    33 // FIXME: Remove this macro once it is not used in WebKit.
    34 #define CERTIFICATE_CREDENTIALS_SUPPORTED 1
     33#if USE(CFNETWORK)
     34typedef const struct _CFURLCredential* CFURLCredentialRef;
     35#endif
     36
     37OBJC_CLASS NSURLCredential;
    3538
    3639namespace WebCore {
    37 
    38 enum CredentialType {
    39     CredentialTypePassword,
    40     CredentialTypeClientCertificate
    41 };
    4240
    4341class Credential : public CredentialBase {
    … …  
    4543    Credential()
    4644        : CredentialBase()
    47         , m_type(CredentialTypePassword)
    4845    {
    4946    }
    … …  
    5148    Credential(const String& user, const String& password, CredentialPersistence persistence)
    5249        : CredentialBase(user, password, persistence)
    53         , m_type(CredentialTypePassword)
    5450    {
    5551    }
    5652
    57     Credential(const Credential& original, CredentialPersistence persistence)
    58         : CredentialBase(original, persistence)
    59         , m_type(original.m_type)
    60     {
    61     }
     53    Credential(const Credential&, CredentialPersistence);
    6254
    63     Credential(SecIdentityRef, CFArrayRef certificates, CredentialPersistence);
     55#if USE(CFNETWORK)
     56    explicit Credential(CFURLCredentialRef);
     57#endif
     58    explicit Credential(NSURLCredential *);
    6459
    6560    bool isEmpty() const;
    6661
    67     SecIdentityRef identity() const;
    68     CFArrayRef certificates() const;
    69     CredentialType type() const;
     62    bool encodingRequiresPlatformData() const { return m_nsCredential && encodingRequiresPlatformData(m_nsCredential.get()); }
     63
     64#if USE(CFNETWORK)
     65    CFURLCredentialRef cfCredential() const;
     66#endif
     67    NSURLCredential *nsCredential() const;
    7068
    7169    static bool platformCompare(const Credential&, const Credential&);
    7270
    7371private:
    74     RetainPtr<SecIdentityRef> m_identity;
    75     RetainPtr<CFArrayRef> m_certificates;
    76     CredentialType m_type;
     72    static bool encodingRequiresPlatformData(NSURLCredential *);
     73
     74    mutable RetainPtr<NSURLCredential> m_nsCredential;
    7775};
    7876

  • trunk/Source/WebCore/platform/network/cocoa/CredentialCocoa.mm

    r171747 r171801  
    2727#import "CredentialCocoa.h"
    2828
     29#if USE(CFNETWORK)
     30@interface NSURLCredential (WebDetails)
     31- (id)_initWithCFURLCredential:(CFURLCredentialRef)credential;
     32- (CFURLCredentialRef) _CFURLCredential;
     33@end
     34#endif
     35
    2936namespace WebCore {
    3037
    31 Credential::Credential(SecIdentityRef identity, CFArrayRef certificates, CredentialPersistence persistence)
    32     : CredentialBase(emptyString(), emptyString(), persistence)
    33     , m_identity(identity)
    34     , m_certificates(certificates)
    35     , m_type(CredentialTypeClientCertificate)
     38static NSURLCredentialPersistence toNSURLCredentialPersistence(CredentialPersistence persistence)
    3639{
     40    switch (persistence) {
     41    case CredentialPersistenceNone:
     42        return NSURLCredentialPersistenceNone;
     43    case CredentialPersistenceForSession:
     44        return NSURLCredentialPersistenceForSession;
     45    case CredentialPersistencePermanent:
     46        return NSURLCredentialPersistencePermanent;
     47    }
     48
     49    ASSERT_NOT_REACHED();
     50    return NSURLCredentialPersistenceNone;
     51}
     52
     53static CredentialPersistence toCredentialPersistence(NSURLCredentialPersistence persistence)
     54{
     55    switch (persistence) {
     56    case NSURLCredentialPersistenceNone:
     57        return CredentialPersistenceNone;
     58    case NSURLCredentialPersistenceForSession:
     59        return CredentialPersistenceForSession;
     60    case NSURLCredentialPersistencePermanent:
     61#if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
     62    case NSURLCredentialPersistenceSynchronizable:
     63#endif
     64        return CredentialPersistencePermanent;
     65    }
     66
     67    ASSERT_NOT_REACHED();
     68    return CredentialPersistenceNone;
     69}
     70
     71Credential::Credential(const Credential& original, CredentialPersistence persistence)
     72    : CredentialBase(original, persistence)
     73{
     74    NSURLCredential *originalNSURLCredential = original.m_nsCredential.get();
     75    if (!originalNSURLCredential)
     76        return;
     77
     78    if (NSString *user = originalNSURLCredential.user)
     79        m_nsCredential = adoptNS([[NSURLCredential alloc] initWithUser:user password:originalNSURLCredential.password persistence:toNSURLCredentialPersistence(persistence)]);
     80    else if (SecIdentityRef identity = originalNSURLCredential.identity)
     81        m_nsCredential = adoptNS([[NSURLCredential alloc] initWithIdentity:identity certificates:originalNSURLCredential.certificates persistence:toNSURLCredentialPersistence(persistence)]);
     82    else {
     83        // It is not possible to set the persistence of server trust credentials.
     84        ASSERT_NOT_REACHED();
     85        m_nsCredential = originalNSURLCredential;
     86    }
     87}
     88
     89#if USE(CFNETWORK)
     90Credential::Credential(CFURLCredentialRef credential)
     91    : Credential(adoptNS([[NSURLCredential alloc] _initWithCFURLCredential:credential]).get())
     92{
     93}
     94#endif
     95
     96Credential::Credential(NSURLCredential *credential)
     97    : CredentialBase(credential.user, credential.password, toCredentialPersistence(credential.persistence))
     98    , m_nsCredential(credential)
     99{
     100}
     101
     102#if USE(CFNETWORK)
     103CFURLCredentialRef Credential::cfCredential() const
     104{
     105    return [nsCredential() _CFURLCredential];
     106}
     107#endif
     108
     109NSURLCredential *Credential::nsCredential() const
     110{
     111    if (m_nsCredential)
     112        return m_nsCredential.get();
     113
     114    if (CredentialBase::isEmpty())
     115        return nil;
     116
     117    m_nsCredential = adoptNS([[NSURLCredential alloc] initWithUser:user() password:password() persistence:toNSURLCredentialPersistence(persistence())]);
     118
     119    return m_nsCredential.get();
    37120}
    38121
    39122bool Credential::isEmpty() const
    40123{
    41     if (m_type == CredentialTypeClientCertificate && (m_identity || m_certificates))
     124    if (m_nsCredential)
    42125        return false;
    43126
    … …  
    45128}
    46129
    47 SecIdentityRef Credential::identity() const
     130bool Credential::platformCompare(const Credential& a, const Credential& b)
    48131{
    49     return m_identity.get();
    50 }
    51    
    52 CFArrayRef Credential::certificates() const
    53 {
    54     return m_certificates.get();
    55 }
    56    
    57 CredentialType Credential::type() const
    58 {
    59     return m_type;
     132    if (!a.m_nsCredential && !b.m_nsCredential)
     133        return true;
     134
     135    return [a.nsCredential() isEqual:b.nsCredential()];
    60136}
    61137
    62 bool Credential::platformCompare(const Credential& a, const Credential& b)
     138bool Credential::encodingRequiresPlatformData(NSURLCredential *credential)
    63139{
    64     if (a.type() != CredentialTypeClientCertificate || b.type() != CredentialTypeClientCertificate)
    65         return a.type() == b.type();
    66 
    67     // FIXME: Is pointer comparison of the identity and certificates properties sufficient?
    68     if (a.identity() != b.identity())
    69         return false;
    70     if (a.certificates() != b.certificates())
    71         return false;
    72 
    73     return true;
     140    return !credential.user;
    74141}
    75142

  • trunk/Source/WebCore/platform/network/mac/AuthenticationMac.h

    r171540 r171801  
    2929
    3030@class NSURLAuthenticationChallenge;
    31 @class NSURLCredential;
    3231
    3332namespace WebCore {
    3433
    3534class AuthenticationChallenge;
    36 class Credential;
    3735
    3836NSURLAuthenticationChallenge *mac(const AuthenticationChallenge&);
    39 NSURLCredential *mac(const Credential&);
    4037
    4138AuthenticationChallenge core(NSURLAuthenticationChallenge *);
    42 Credential core(NSURLCredential *);
    4339
    4440}

  • trunk/Source/WebCore/platform/network/mac/AuthenticationMac.mm

    r171747 r171801  
    3131#import "Credential.h"
    3232#import <Foundation/NSURLAuthenticationChallenge.h>
    33 #import <Foundation/NSURLCredential.h>
    3433#import <Foundation/NSURLProtectionSpace.h>
    3534
    … …  
    4443@end
    4544
    46 @interface NSURLCredential (Details)
    47 - (id) _initWithCFURLCredential:(CFURLCredentialRef)credential;
    48 - (CFURLCredentialRef) _cfurlcredential;
    49 @end
    50 
    5145#endif
    5246
    … …  
    8983{
    9084    if (m_client)
    91         m_client->receivedCredential(core(challenge), core(credential));
     85        m_client->receivedCredential(core(challenge), Credential(credential));
    9286}
    9387
    … …  
    126120    WebCoreAuthenticationClientAsChallengeSender *challengeSender = (WebCoreAuthenticationClientAsChallengeSender*) [macChallenge sender];
    127121    return AuthenticationChallenge([challengeSender cfChallenge], [challengeSender client]);
    128 }
    129 
    130 Credential core(NSURLCredential *macCredential)
    131 {
    132     return core([macCredential _cfurlcredential]);
    133122}
    134123
    … …  
    148137}
    149138
    150 NSURLCredential *mac(const Credential& coreCredential)
    151 {
    152     RetainPtr<CFURLCredentialRef> credential = adoptCF(createCF(coreCredential));
    153     return [[[NSURLCredential alloc] _initWithCFURLCredential:credential.get()] autorelease];
    154 }
    155 
    156139#else
    157140
    … …  
    171154AuthenticationChallenge::AuthenticationChallenge(NSURLAuthenticationChallenge *challenge)
    172155    : AuthenticationChallengeBase(ProtectionSpace([challenge protectionSpace]),
    173                                   core([challenge proposedCredential]),
     156                                  Credential([challenge proposedCredential]),
    174157                                  [challenge previousFailureCount],
    175158                                  [challenge failureResponse],
    … …  
    217200       
    218201    return [[[NSURLAuthenticationChallenge alloc] initWithProtectionSpace:coreChallenge.protectionSpace().nsSpace()
    219                                                        proposedCredential:mac(coreChallenge.proposedCredential())
     202                                                       proposedCredential:coreChallenge.proposedCredential().nsCredential()
    220203                                                     previousFailureCount:coreChallenge.previousFailureCount()
    221204                                                          failureResponse:coreChallenge.failureResponse().nsURLResponse()
    … …  
    224207}
    225208
    226 NSURLCredential *mac(const Credential& coreCredential)
    227 {
    228     if (coreCredential.isEmpty())
    229         return nil;
    230 
    231     NSURLCredentialPersistence persistence = NSURLCredentialPersistenceNone;
    232     switch (coreCredential.persistence()) {
    233         case CredentialPersistenceNone:
    234             break;
    235         case CredentialPersistenceForSession:
    236             persistence = NSURLCredentialPersistenceForSession;
    237             break;
    238         case CredentialPersistencePermanent:
    239             persistence = NSURLCredentialPersistencePermanent;
    240             break;
    241         default:
    242             ASSERT_NOT_REACHED();
    243     }
    244 
    245     if (coreCredential.type() == CredentialTypeClientCertificate) {
    246         return [[[NSURLCredential alloc] initWithIdentity:coreCredential.identity()
    247                                              certificates:(NSArray *)coreCredential.certificates()
    248                                               persistence:persistence]
    249                                               autorelease];
    250     }
    251 
    252     return [[[NSURLCredential alloc] initWithUser:coreCredential.user()
    253                                         password:coreCredential.password()
    254                                      persistence:persistence]
    255                                      autorelease];
    256 }
    257 
    258209AuthenticationChallenge core(NSURLAuthenticationChallenge *macChallenge)
    259210{
    … …  
    261212}
    262213
    263 Credential core(NSURLCredential *macCredential)
    264 {
    265     CredentialPersistence persistence = CredentialPersistenceNone;
    266     switch ([macCredential persistence]) {
    267         case NSURLCredentialPersistenceNone:
    268             break;
    269         case NSURLCredentialPersistenceForSession:
    270             persistence = CredentialPersistenceForSession;
    271             break;
    272         case NSURLCredentialPersistencePermanent:
    273             persistence = CredentialPersistencePermanent;
    274             break;
    275         default:
    276             ASSERT_NOT_REACHED();
    277     }
    278 
    279     SecIdentityRef identity = [macCredential identity];
    280     if (identity)
    281         return Credential(identity, (CFArrayRef)[macCredential certificates], persistence);
    282    
    283     return Credential([macCredential user], [macCredential password], persistence);
    284 }
    285 
    286214#endif // USE(CFNETWORK)
    287215

  • trunk/Source/WebCore/platform/network/mac/CredentialStorageMac.mm

    r171540 r171801  
    3838{
    3939    NSURLCredential *credential = [[NSURLCredentialStorage sharedCredentialStorage] defaultCredentialForProtectionSpace:protectionSpace.nsSpace()];
    40     return credential ? core(credential) : Credential();
     40    return credential ? Credential(credential) : Credential();
    4141}
    4242

  • trunk/Source/WebCore/platform/network/mac/ResourceHandleMac.mm

    r171608 r171801  
    550550        d->m_currentMacChallenge = challenge.nsURLAuthenticationChallenge();
    551551        d->m_currentWebChallenge = challenge;
    552         receivedCredential(challenge, core(credential));
     552        receivedCredential(challenge, Credential(credential));
    553553        [credential release];
    554554        // FIXME: Per the specification, the user shouldn't be asked for credentials if there were incorrect ones provided explicitly.
    … …  
    575575                    CredentialStorage::set(credential, challenge.protectionSpace(), challenge.failureResponse().url());
    576576                }
    577                 [challenge.sender() useCredential:mac(credential) forAuthenticationChallenge:mac(challenge)];
     577                [challenge.sender() useCredential:credential.nsCredential() forAuthenticationChallenge:mac(challenge)];
    578578                return;
    579579            }
    … …  
    659659            urlToStore = challenge.failureResponse().url();
    660660        CredentialStorage::set(webCredential, ProtectionSpace([d->m_currentMacChallenge protectionSpace]), urlToStore);
    661         [[d->m_currentMacChallenge sender] useCredential:mac(webCredential) forAuthenticationChallenge:d->m_currentMacChallenge];
     661        [[d->m_currentMacChallenge sender] useCredential:webCredential.nsCredential() forAuthenticationChallenge:d->m_currentMacChallenge];
    662662    } else
    663         [[d->m_currentMacChallenge sender] useCredential:mac(credential) forAuthenticationChallenge:d->m_currentMacChallenge];
     663        [[d->m_currentMacChallenge sender] useCredential:credential.nsCredential() forAuthenticationChallenge:d->m_currentMacChallenge];
    664664
    665665    clearAuthentication();

  • trunk/Source/WebKit/mac/ChangeLog

    r171673 r171801  
     12014-07-30  Dan Bernstein  <mitz@apple.com>
     2
     3        Updated for changes to the WebCore::Credential API.
     4        Work towards fixing https://bugs.webkit.org/show_bug.cgi?id=135327
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        * Misc/WebDownload.mm:
     9        (-[WebDownloadInternal download:didReceiveAuthenticationChallenge:]): Use new nsCredential
     10        getter.
     11        * Plugins/WebBaseNetscapePluginView.mm:
     12        (WebKit::getAuthenticationInfo): Ditto.
     13
    1142014-07-27  Pratik Solanki  <psolanki@apple.com>
    215

  • trunk/Source/WebKit/mac/Misc/WebDownload.mm

    r171540 r171801  
    129129    // Try previously stored credential first.
    130130    if (![challenge previousFailureCount]) {
    131         NSURLCredential *credential = mac(CredentialStorage::get(ProtectionSpace([challenge protectionSpace])));
     131        NSURLCredential *credential = CredentialStorage::get(ProtectionSpace([challenge protectionSpace])).nsCredential();
    132132        if (credential) {
    133133            [[challenge sender] useCredential:credential forAuthenticationChallenge:challenge];

  • trunk/Source/WebKit/mac/Plugins/WebBaseNetscapePluginView.mm

    r171540 r171801  
    929929    RetainPtr<NSURLProtectionSpace> protectionSpace = adoptNS([[NSURLProtectionSpace alloc] initWithHost:host port:port protocol:protocol realm:realm authenticationMethod:authenticationMethod]);
    930930   
    931     NSURLCredential *credential = mac(CredentialStorage::get(ProtectionSpace(protectionSpace.get())));
     931    NSURLCredential *credential = CredentialStorage::get(ProtectionSpace(protectionSpace.get())).nsCredential();
    932932    if (!credential)
    933933        credential = [[NSURLCredentialStorage sharedCredentialStorage] defaultCredentialForProtectionSpace:protectionSpace.get()];

  • trunk/Source/WebKit2/ChangeLog

    r171796 r171801  
     12014-07-30  Dan Bernstein  <mitz@apple.com>
     2
     3        Updated for changes to the WebCore::Credential API.
     4        Work towards fixing https://bugs.webkit.org/show_bug.cgi?id=135327
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        * Shared/Downloads/mac/DownloadMac.mm:
     9        (WebKit::Download::receivedCredential):Use new Credential::nsCredential getter.
     10
     11        * Shared/WebCoreArgumentCoders.cpp:
     12        (IPC::ArgumentCoder<Credential>::encode):  If encoding the credential requires encoding the
     13        platform data, do that.
     14        (IPC::ArgumentCoder<Credential>::decode): If platform data was encoded, decode it.
     15        * Shared/WebCoreArgumentCoders.h:
     16
     17        * Shared/mac/WebCoreArgumentCodersMac.mm:
     18        (IPC::ArgumentCoder<Credential>::encodePlatformData): Archive the NSURLCredential.
     19        (IPC::ArgumentCoder<Credential>::decodePlatformData): Unarchive it.
     20
     21        * UIProcess/API/Cocoa/WKNSURLAuthenticationChallenge.mm:
     22        (-[WKNSURLAuthenticationChallengeSender useCredential:forAuthenticationChallenge:]): Use
     23        Credential constructor that takes an NSURLCredential.
     24
     25        * UIProcess/Cocoa/NavigationState.mm:
     26        (WebKit::NavigationState::LoaderClient::didReceiveAuthenticationChallengeInFrame): Ditto.
     27
     28
    1292014-07-30  Carlos Garcia Campos  <cgarcia@igalia.com>
    230

  • trunk/Source/WebKit2/Shared/Downloads/mac/DownloadMac.mm

    r169782 r171801  
    113113void Download::receivedCredential(const AuthenticationChallenge& authenticationChallenge, const Credential& credential)
    114114{
    115     [authenticationChallenge.sender() useCredential:mac(credential) forAuthenticationChallenge:authenticationChallenge.nsURLAuthenticationChallenge()];
     115    [authenticationChallenge.sender() useCredential:credential.nsCredential() forAuthenticationChallenge:authenticationChallenge.nsURLAuthenticationChallenge()];
    116116}
    117117

  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp

    r171540 r171801  
    507507void ArgumentCoder<Credential>::encode(ArgumentEncoder& encoder, const Credential& credential)
    508508{
    509 #if CERTIFICATE_CREDENTIALS_SUPPORTED
    510     encoder.encodeEnum(credential.type());
    511 
    512     if (credential.type() == CredentialTypeClientCertificate) {
    513         IPC::encode(encoder, credential.identity());
    514 
    515         encoder << !!credential.certificates();
    516         if (credential.certificates())
    517             IPC::encode(encoder, credential.certificates());
    518 
    519         encoder.encodeEnum(credential.persistence());
     509    if (credential.encodingRequiresPlatformData()) {
     510        encoder << true;
     511        encodePlatformData(encoder, credential);
    520512        return;
    521513    }
    522 #endif
     514
     515    encoder << false;
    523516    encoder << credential.user() << credential.password();
    524 
    525517    encoder.encodeEnum(credential.persistence());
    526518}
    … …  
    528520bool ArgumentCoder<Credential>::decode(ArgumentDecoder& decoder, Credential& credential)
    529521{
    530 #if CERTIFICATE_CREDENTIALS_SUPPORTED
    531     CredentialType type;
    532 
    533     if (!decoder.decodeEnum(type))
    534         return false;
    535 
    536     if (type == CredentialTypeClientCertificate) {
    537         RetainPtr<SecIdentityRef> identity;
    538         if (!IPC::decode(decoder, identity))
    539             return false;
    540 
    541         bool hasCertificates;
    542         if (!decoder.decode(hasCertificates))
    543             return false;
    544 
    545         RetainPtr<CFArrayRef> certificates;
    546         if (hasCertificates) {
    547             if (!IPC::decode(decoder, certificates))
    548                 return false;
    549         }
    550 
    551         CredentialPersistence persistence;
    552         if (!decoder.decodeEnum(persistence))
    553             return false;
    554 
    555         credential = Credential(identity.get(), certificates.get(), persistence);
    556         return true;
    557     }
    558 #endif
     522    bool hasPlatformData;
     523    if (!decoder.decode(hasPlatformData))
     524        return false;
     525
     526    if (hasPlatformData)
     527        return decodePlatformData(decoder, credential);
    559528
    560529    String user;

  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.h

    r171540 r171801  
    236236    static void encode(ArgumentEncoder&, const WebCore::Credential&);
    237237    static bool decode(ArgumentDecoder&, WebCore::Credential&);
     238    static void encodePlatformData(ArgumentEncoder&, const WebCore::Credential&);
     239    static bool decodePlatformData(ArgumentDecoder&, WebCore::Credential&);
    238240};
    239241

  • trunk/Source/WebKit2/Shared/mac/WebCoreArgumentCodersMac.mm

    r171540 r171801  
    3333#import <WebCore/CertificateInfo.h>
    3434#import <WebCore/ContentFilter.h>
     35#import <WebCore/Credential.h>
    3536#import <WebCore/KeyboardEvent.h>
    3637#import <WebCore/ProtectionSpace.h>
    … …  
    316317}
    317318
     319void ArgumentCoder<Credential>::encodePlatformData(ArgumentEncoder& encoder, const Credential& credential)
     320{
     321    RetainPtr<NSMutableData> data = adoptNS([[NSMutableData alloc] init]);
     322    RetainPtr<NSKeyedArchiver> archiver = adoptNS([[NSKeyedArchiver alloc] initForWritingWithMutableData:data.get()]);
     323    [archiver setRequiresSecureCoding:YES];
     324    [archiver encodeObject:credential.nsCredential() forKey:@"credential"];
     325    [archiver finishEncoding];
     326    IPC::encode(encoder, reinterpret_cast<CFDataRef>(data.get()));
     327}
     328
     329bool ArgumentCoder<Credential>::decodePlatformData(ArgumentDecoder& decoder, Credential& credential)
     330{
     331    RetainPtr<CFDataRef> data;
     332    if (!IPC::decode(decoder, data))
     333        return false;
     334
     335    RetainPtr<NSKeyedUnarchiver> unarchiver = adoptNS([[NSKeyedUnarchiver alloc] initForReadingWithData:(NSData *)data.get()]);
     336    [unarchiver setRequiresSecureCoding:YES];
     337    @try {
     338        if (RetainPtr<NSURLCredential> nsCredential = [unarchiver decodeObjectOfClass:[NSURLCredential class] forKey:@"credential"])
     339            credential = Credential(nsCredential.get());
     340    } @catch (NSException *exception) {
     341        LOG_ERROR("Failed to decode NSURLCredential: %@", exception);
     342    }
     343
     344    [unarchiver finishDecoding];
     345    return true;
     346}
     347
    318348void ArgumentCoder<KeypressCommand>::encode(ArgumentEncoder& encoder, const KeypressCommand& keypressCommand)
    319349{

  • trunk/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp

    r171540 r171801  
    153153}
    154154
     155void ArgumentCoder<Credential>::encodePlatformData(ArgumentEncoder&, const Credential&)
     156{
     157    ASSERT_NOT_REACHED();
    155158}
    156159
     160bool ArgumentCoder<Credential>::decodePlatformData(ArgumentDecoder&, Credential&)
     161{
     162    ASSERT_NOT_REACHED();
     163    return false;
     164}
     165
     166}
     167

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKNSURLAuthenticationChallenge.mm

    r169782 r171801  
    8888    checkChallenge(challenge);
    8989    AuthenticationChallengeProxy& webChallenge = ((WKNSURLAuthenticationChallenge *)challenge)._web_authenticationChallengeProxy;
    90     webChallenge.listener()->useCredential(WebCredential::create(core(credential)).get());
     90    webChallenge.listener()->useCredential(WebCredential::create(Credential(credential)).get());
    9191}
    9292

  • trunk/Source/WebKit2/UIProcess/Cocoa/NavigationState.mm

    r171626 r171801  
    5757#import "_WKErrorRecoveryAttempting.h"
    5858#import "_WKFrameHandleInternal.h"
    59 #import <WebCore/AuthenticationMac.h>
     59#import <WebCore/Credential.h>
    6060#import <wtf/NeverDestroyed.h>
    6161
    … …  
    725725                    RefPtr<WebCredential> webCredential;
    726726                    if (credential)
    727                         webCredential = WebCredential::create(WebCore::core(credential));
     727                        webCredential = WebCredential::create(WebCore::Credential(credential));
    728728
    729729                    challenge->listener()->useCredential(webCredential.get());
Note: See TracChangeset for help on using the changeset viewer.