Rubber-stamped by Darin Adler.

        Don't keep platform objects for authentication challenge in ResourceHandleInternal.
        We already have a copy in AuthenticationChallenge object.

        * platform/network/ResourceHandle.cpp:
        (WebCore::ResourceHandle::clearAuthentication):
        * platform/network/ResourceHandleInternal.h:
        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
        * platform/network/cf/ResourceHandleCFNet.cpp:
        (WebCore::ResourceHandle::didReceiveAuthenticationChallenge):
        (WebCore::ResourceHandle::receivedCredential):
        (WebCore::ResourceHandle::receivedRequestToContinueWithoutCredential):
        (WebCore::ResourceHandle::receivedCancellation):
        * platform/network/mac/ResourceHandleMac.mm:
        (WebCore::ResourceHandle::didReceiveAuthenticationChallenge):
        (WebCore::ResourceHandle::didCancelAuthenticationChallenge):
        (WebCore::ResourceHandle::receivedCredential):
        (WebCore::ResourceHandle::receivedRequestToContinueWithoutCredential):
        (WebCore::ResourceHandle::receivedCancellation):



git-svn-id: svn://svn.chromium.org/blink/trunk@42536 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/WebCore/ChangeLog

+2009-04-14  Alexey Proskuryakov  <ap@webkit.org>
+
+        Rubber-stamped by Darin Adler.
+
+        Don't keep platform objects for authentication challenge in ResourceHandleInternal.
+        We already have a copy in AuthenticationChallenge object.
+
+        * platform/network/ResourceHandle.cpp:
+        (WebCore::ResourceHandle::clearAuthentication):
+        * platform/network/ResourceHandleInternal.h:
+        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
+        * platform/network/cf/ResourceHandleCFNet.cpp:
+        (WebCore::ResourceHandle::didReceiveAuthenticationChallenge):
+        (WebCore::ResourceHandle::receivedCredential):
+        (WebCore::ResourceHandle::receivedRequestToContinueWithoutCredential):
+        (WebCore::ResourceHandle::receivedCancellation):
+        * platform/network/mac/ResourceHandleMac.mm:
+        (WebCore::ResourceHandle::didReceiveAuthenticationChallenge):
+        (WebCore::ResourceHandle::didCancelAuthenticationChallenge):
+        (WebCore::ResourceHandle::receivedCredential):
+        (WebCore::ResourceHandle::receivedRequestToContinueWithoutCredential):
+        (WebCore::ResourceHandle::receivedCancellation):
+
 2009-04-14  Geoffrey Garen  <ggaren@apple.com>
 
         Reviewed by Sam Weinig.

third_party/WebKit/WebCore/platform/network/ResourceHandle.cpp

@@ -103,12 +103,7 @@ const ResourceRequest& ResourceHandle::request() const
 
 void ResourceHandle::clearAuthentication()
 {
-#if PLATFORM(MAC)
-    d->m_currentMacChallenge = nil;
-#elif USE(CFNETWORK)
-    d->m_currentCFChallenge = 0;
-#endif
-    d->m_currentWebChallenge.nullify();
+    d->m_currentChallenge.nullify();
 }
 
 static bool portAllowed(const ResourceRequest& request)

third_party/WebKit/WebCore/platform/network/ResourceHandleInternal.h

@@ -127,9 +127,6 @@ namespace WebCore {
 #endif
 #if PLATFORM(MAC)
             , m_startWhenScheduled(false)
-            , m_currentMacChallenge(nil)
-#elif USE(CFNETWORK)
-            , m_currentCFChallenge(0)
 #endif
             , m_failureTimer(loader, &ResourceHandle::fireFailure)
         {
@@ -209,13 +206,7 @@ namespace WebCore {
 #endif
         QWebFrame* m_frame;
 #endif
-#if PLATFORM(MAC)
-        NSURLAuthenticationChallenge *m_currentMacChallenge;
-#endif
-#if USE(CFNETWORK)
-        CFURLAuthChallengeRef m_currentCFChallenge;
-#endif
-        AuthenticationChallenge m_currentWebChallenge;
+        AuthenticationChallenge m_currentChallenge;
 
         ResourceHandle::FailureType m_failureType;
         Timer<ResourceHandle> m_failureTimer;

third_party/WebKit/WebCore/platform/network/cf/ResourceHandleCFNet.cpp

@@ -409,8 +409,7 @@ bool ResourceHandle::shouldUseCredentialStorage()
 void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge)
 {
     LOG(Network, "CFNet - didReceiveAuthenticationChallenge()");
-    ASSERT(!d->m_currentCFChallenge);
-    ASSERT(d->m_currentWebChallenge.isNull());
+    ASSERT(d->m_currentChallenge.isNull());
     // Since CFURLConnection networking relies on keeping a reference to the original CFURLAuthChallengeRef,
     // we make sure that is actually present
     ASSERT(challenge.cfURLAuthChallengeRef());
@@ -437,11 +436,10 @@ void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChall
         }
     }
 
-    d->m_currentCFChallenge = challenge.cfURLAuthChallengeRef();
-    d->m_currentWebChallenge = AuthenticationChallenge(d->m_currentCFChallenge, this);
+    d->m_currentChallenge = AuthenticationChallenge(challenge.cfURLAuthChallengeRef(), this);
     
     if (client())
-        client()->didReceiveAuthenticationChallenge(this, d->m_currentWebChallenge);
+        client()->didReceiveAuthenticationChallenge(this, d->m_currentChallenge);
 }
 
 void ResourceHandle::receivedCredential(const AuthenticationChallenge& challenge, const Credential& credential)
@@ -449,7 +447,7 @@ void ResourceHandle::receivedCredential(const AuthenticationChallenge& challenge
     LOG(Network, "CFNet - receivedCredential()");
     ASSERT(!challenge.isNull());
     ASSERT(challenge.cfURLAuthChallengeRef());
-    if (challenge != d->m_currentWebChallenge)
+    if (challenge != d->m_currentChallenge)
         return;
 
     if (credential.persistence() == CredentialPersistenceForSession) {
@@ -472,7 +470,7 @@ void ResourceHandle::receivedRequestToContinueWithoutCredential(const Authentica
     LOG(Network, "CFNet - receivedRequestToContinueWithoutCredential()");
     ASSERT(!challenge.isNull());
     ASSERT(challenge.cfURLAuthChallengeRef());
-    if (challenge != d->m_currentWebChallenge)
+    if (challenge != d->m_currentChallenge)
         return;
 
     CFURLConnectionUseCredential(d->m_connection.get(), 0, challenge.cfURLAuthChallengeRef());
@@ -483,7 +481,7 @@ void ResourceHandle::receivedRequestToContinueWithoutCredential(const Authentica
 void ResourceHandle::receivedCancellation(const AuthenticationChallenge& challenge)
 {
     LOG(Network, "CFNet - receivedCancellation()");
-    if (challenge != d->m_currentWebChallenge)
+    if (challenge != d->m_currentChallenge)
         return;
 
     if (client())

third_party/WebKit/WebCore/platform/network/mac/ResourceHandleMac.mm

@@ -406,8 +406,7 @@ bool ResourceHandle::shouldUseCredentialStorage()
 
 void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge)
 {
-    ASSERT(!d->m_currentMacChallenge);
-    ASSERT(d->m_currentWebChallenge.isNull());
+    ASSERT(d->m_currentChallenge.isNull());
     // Since NSURLConnection networking relies on keeping a reference to the original NSURLAuthenticationChallenge,
     // we make sure that is actually present
     ASSERT(challenge.nsURLAuthenticationChallenge());
@@ -416,8 +415,7 @@ void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChall
         NSURLCredential *credential = [[NSURLCredential alloc] initWithUser:d->m_user
                                                                    password:d->m_pass
                                                                 persistence:NSURLCredentialPersistenceNone];
-        d->m_currentMacChallenge = challenge.nsURLAuthenticationChallenge();
-        d->m_currentWebChallenge = challenge;
+        d->m_currentChallenge = challenge;
         receivedCredential(challenge, core(credential));
         [credential release];
         // FIXME: Per the specification, the user shouldn't be asked for credentials if there were incorrect ones provided explicitly.
@@ -434,21 +432,19 @@ void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChall
         }
     }
 
-    d->m_currentMacChallenge = challenge.nsURLAuthenticationChallenge();
-    NSURLAuthenticationChallenge *webChallenge = [[NSURLAuthenticationChallenge alloc] initWithAuthenticationChallenge:d->m_currentMacChallenge 
+    NSURLAuthenticationChallenge *webChallenge = [[NSURLAuthenticationChallenge alloc] initWithAuthenticationChallenge:challenge.nsURLAuthenticationChallenge() 
                                                                                        sender:(id<NSURLAuthenticationChallengeSender>)delegate()];
-    d->m_currentWebChallenge = core(webChallenge);
+    d->m_currentChallenge = core(webChallenge);
     [webChallenge release];
 
     if (client())
-        client()->didReceiveAuthenticationChallenge(this, d->m_currentWebChallenge);
+        client()->didReceiveAuthenticationChallenge(this, d->m_currentChallenge);
 }
 
 void ResourceHandle::didCancelAuthenticationChallenge(const AuthenticationChallenge& challenge)
 {
-    ASSERT(d->m_currentMacChallenge);
-    ASSERT(!d->m_currentWebChallenge.isNull());
-    ASSERT(d->m_currentWebChallenge == challenge);
+    ASSERT(!d->m_currentChallenge.isNull());
+    ASSERT(d->m_currentChallenge == challenge);
 
     if (client())
         client()->didCancelAuthenticationChallenge(this, challenge);
@@ -457,26 +453,28 @@ void ResourceHandle::didCancelAuthenticationChallenge(const AuthenticationChalle
 void ResourceHandle::receivedCredential(const AuthenticationChallenge& challenge, const Credential& credential)
 {
     ASSERT(!challenge.isNull());
-    if (challenge != d->m_currentWebChallenge)
+    if (challenge != d->m_currentChallenge)
         return;
 
+    NSURLAuthenticationChallenge *currentMacChallenge = challenge.nsURLAuthenticationChallenge();
+
 #ifdef BUILDING_ON_TIGER
     if (credential.persistence() == CredentialPersistenceNone) {
         // NSURLCredentialPersistenceNone doesn't work on Tiger, so we have to use session persistence.
         Credential webCredential(credential.user(), credential.password(), CredentialPersistenceForSession);
-        WebCoreCredentialStorage::set(mac(webCredential), [d->m_currentMacChallenge protectionSpace]);
-        [[d->m_currentMacChallenge sender] useCredential:mac(webCredential) forAuthenticationChallenge:d->m_currentMacChallenge];
+        WebCoreCredentialStorage::set(mac(webCredential), [currentMacChallenge protectionSpace]);
+        [[currentMacChallenge sender] useCredential:mac(webCredential) forAuthenticationChallenge:currentMacChallenge];
     } else
 #else
     if (credential.persistence() == CredentialPersistenceForSession) {
         // Manage per-session credentials internally, because once NSURLCredentialPersistenceForSession is used, there is no way
         // to ignore it for a particular request (short of removing it altogether).
         Credential webCredential(credential.user(), credential.password(), CredentialPersistenceNone);
-        WebCoreCredentialStorage::set(mac(webCredential), [d->m_currentMacChallenge protectionSpace]);
-        [[d->m_currentMacChallenge sender] useCredential:mac(webCredential) forAuthenticationChallenge:d->m_currentMacChallenge];
+        WebCoreCredentialStorage::set(mac(webCredential), [currentMacChallenge protectionSpace]);
+        [[currentMacChallenge sender] useCredential:mac(webCredential) forAuthenticationChallenge:currentMacChallenge];
     } else
 #endif
-        [[d->m_currentMacChallenge sender] useCredential:mac(credential) forAuthenticationChallenge:d->m_currentMacChallenge];
+        [[currentMacChallenge sender] useCredential:mac(credential) forAuthenticationChallenge:currentMacChallenge];
 
     clearAuthentication();
 }
@@ -484,17 +482,18 @@ void ResourceHandle::receivedCredential(const AuthenticationChallenge& challenge
 void ResourceHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge& challenge)
 {
     ASSERT(!challenge.isNull());
-    if (challenge != d->m_currentWebChallenge)
+    if (challenge != d->m_currentChallenge)
         return;
 
-    [[d->m_currentMacChallenge sender] continueWithoutCredentialForAuthenticationChallenge:d->m_currentMacChallenge];
+    NSURLAuthenticationChallenge *currentMacChallenge = challenge.nsURLAuthenticationChallenge();
+    [[currentMacChallenge sender] continueWithoutCredentialForAuthenticationChallenge:currentMacChallenge];
 
     clearAuthentication();
 }
 
 void ResourceHandle::receivedCancellation(const AuthenticationChallenge& challenge)
 {
-    if (challenge != d->m_currentWebChallenge)
+    if (challenge != d->m_currentChallenge)
         return;
 
     if (client())