[BlackBerry] Really fix bug 95488 that user can get the authentication challenge...
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 21 Sep 2012 21:02:37 +0000 (21:02 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 21 Sep 2012 21:02:37 +0000 (21:02 +0000)
https://bugs.webkit.org/show_bug.cgi?id=97348
Internal PR: 186597.

Internally reviewed by Yong Li, Joe Mason.
Patch by Lianghui Chen <liachen@rim.com> on 2012-09-21
Reviewed by Yong Li.

Source/WebCore:

Add a singleton AuthenticationChallengeManager to manage authentication
challenge dialog. It does following things:
Record page creation/deletion, so it knows what page is present or not.
Record page visibility change so it knows when to display a dialog or not.
Accept authentication challenge, and decide whether to postpone the
    challenge dialog based on whether there is active authentication challenge
    dialog already and whether its page is visible or not.
When a challenge result comes back, notify the result to all clients
    authenticating for the same protection space, and then start the next
    authentication challenge from the same page, if there is one.
When a page becomes visible, start the first authentication challenge
    dialog that has been blocked before.

And to support this new AuthenticationChallengeManager, and making the
    challenge really asynchronous, NetworkJob has been updated to support
    the concept of "freeze", which means buffering all network loading status
    change but don't send them to NetworkJob clients.
This is necessary when authentication challenge is asynchronous, as the
    previous network loading status will likely come before user make any
    decision.

No new tests for platform specific internal change.

* PlatformBlackBerry.cmake:
* platform/blackberry/AuthenticationChallengeManager.cpp: Added.
(WebCore):
(ChallengeInfo):
(WebCore::ChallengeInfo::ChallengeInfo):
(AuthenticationChallengeManagerPrivate):
(WebCore::AuthenticationChallengeManagerPrivate::AuthenticationChallengeManagerPrivate):
(WebCore::AuthenticationChallengeManagerPrivate::resumeAuthenticationChallenge):
(WebCore::AuthenticationChallengeManagerPrivate::startAuthenticationChallenge):
(WebCore::AuthenticationChallengeManagerPrivate::pageExists):
(WebCore::AuthenticationChallengeManager::AuthenticationChallengeManager):
(WebCore::AuthenticationChallengeManager::pageCreated):
(WebCore::AuthenticationChallengeManager::pageDeleted):
(WebCore::AuthenticationChallengeManager::pageVisibilityChanged):
(WebCore::AuthenticationChallengeManager::authenticationChallenge):
(WebCore::AuthenticationChallengeManager::cancelAuthenticationChallenge):
(WebCore::AuthenticationChallengeManager::notifyChallengeResult):
(WebCore::AuthenticationChallengeManager::instance):
(WebCore::AuthenticationChallengeManager::init):
* platform/blackberry/AuthenticationChallengeManager.h:
(WebCore):
(AuthenticationChallengeManager):
* platform/blackberry/PageClientBlackBerry.h:
* platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp:
(WebCore::MediaPlayerPrivate::MediaPlayerPrivate):
(WebCore::MediaPlayerPrivate::~MediaPlayerPrivate):
(WebCore::MediaPlayerPrivate::onAuthenticationNeeded):
(WebCore::MediaPlayerPrivate::notifyChallengeResult):
* platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.h:
(MediaPlayerPrivate):
* platform/network/blackberry/NetworkJob.cpp:
(WebCore::NetworkJob::NetworkJob):
(WebCore::NetworkJob::~NetworkJob):
(WebCore):
(WebCore::NetworkJob::handleNotifyStatusReceived):
(WebCore::NetworkJob::handleNotifyClose):
(WebCore::NetworkJob::sendRequestWithCredentials):
(WebCore::NetworkJob::notifyChallengeResult):
* platform/network/blackberry/NetworkJob.h:
(NetworkJob):

Source/WebKit/blackberry:

Update WebPage to use new AuthenticationChallengeManager.
Register page creation/deletion and visibility change to the new
    AuthenticationChallengeManager.
Initialize AuthenticationChallengeManager in GlobalInitialize() function.

* Api/BlackBerryGlobal.cpp:
(BlackBerry::WebKit::globalInitialize):
* Api/WebPage.cpp:
(BlackBerry::WebKit::WebPagePrivate::WebPagePrivate):
(BlackBerry::WebKit::WebPagePrivate::~WebPagePrivate):
(BlackBerry::WebKit::WebPagePrivate::authenticationChallenge):
(BlackBerry::WebKit::WebPage::setVisible):
* Api/WebPage_p.h:
(WebPagePrivate):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@129251 268f45cc-cd09-0410-ab3c-d52691b4dbfc

13 files changed:
Source/WebCore/ChangeLog
Source/WebCore/PlatformBlackBerry.cmake
Source/WebCore/platform/blackberry/AuthenticationChallengeManager.cpp [new file with mode: 0644]
Source/WebCore/platform/blackberry/AuthenticationChallengeManager.h
Source/WebCore/platform/blackberry/PageClientBlackBerry.h
Source/WebCore/platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp
Source/WebCore/platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.h
Source/WebCore/platform/network/blackberry/NetworkJob.cpp
Source/WebCore/platform/network/blackberry/NetworkJob.h
Source/WebKit/blackberry/Api/BlackBerryGlobal.cpp
Source/WebKit/blackberry/Api/WebPage.cpp
Source/WebKit/blackberry/Api/WebPage_p.h
Source/WebKit/blackberry/ChangeLog

index 08bca24..b3e3b8a 100644 (file)
@@ -1,3 +1,76 @@
+2012-09-21  Lianghui Chen  <liachen@rim.com>
+
+        [BlackBerry] Really fix bug 95488 that user can get the authentication challenge dialog while the other tab has focus.
+        https://bugs.webkit.org/show_bug.cgi?id=97348
+        Internal PR: 186597.
+
+        Internally reviewed by Yong Li, Joe Mason.
+        Reviewed by Yong Li.
+
+        Add a singleton AuthenticationChallengeManager to manage authentication
+        challenge dialog. It does following things:
+        Record page creation/deletion, so it knows what page is present or not.
+        Record page visibility change so it knows when to display a dialog or not.
+        Accept authentication challenge, and decide whether to postpone the
+            challenge dialog based on whether there is active authentication challenge
+            dialog already and whether its page is visible or not.
+        When a challenge result comes back, notify the result to all clients
+            authenticating for the same protection space, and then start the next
+            authentication challenge from the same page, if there is one.
+        When a page becomes visible, start the first authentication challenge
+            dialog that has been blocked before.
+
+        And to support this new AuthenticationChallengeManager, and making the
+            challenge really asynchronous, NetworkJob has been updated to support
+            the concept of "freeze", which means buffering all network loading status
+            change but don't send them to NetworkJob clients.
+        This is necessary when authentication challenge is asynchronous, as the
+            previous network loading status will likely come before user make any
+            decision.
+
+        No new tests for platform specific internal change.
+
+        * PlatformBlackBerry.cmake:
+        * platform/blackberry/AuthenticationChallengeManager.cpp: Added.
+        (WebCore):
+        (ChallengeInfo):
+        (WebCore::ChallengeInfo::ChallengeInfo):
+        (AuthenticationChallengeManagerPrivate):
+        (WebCore::AuthenticationChallengeManagerPrivate::AuthenticationChallengeManagerPrivate):
+        (WebCore::AuthenticationChallengeManagerPrivate::resumeAuthenticationChallenge):
+        (WebCore::AuthenticationChallengeManagerPrivate::startAuthenticationChallenge):
+        (WebCore::AuthenticationChallengeManagerPrivate::pageExists):
+        (WebCore::AuthenticationChallengeManager::AuthenticationChallengeManager):
+        (WebCore::AuthenticationChallengeManager::pageCreated):
+        (WebCore::AuthenticationChallengeManager::pageDeleted):
+        (WebCore::AuthenticationChallengeManager::pageVisibilityChanged):
+        (WebCore::AuthenticationChallengeManager::authenticationChallenge):
+        (WebCore::AuthenticationChallengeManager::cancelAuthenticationChallenge):
+        (WebCore::AuthenticationChallengeManager::notifyChallengeResult):
+        (WebCore::AuthenticationChallengeManager::instance):
+        (WebCore::AuthenticationChallengeManager::init):
+        * platform/blackberry/AuthenticationChallengeManager.h:
+        (WebCore):
+        (AuthenticationChallengeManager):
+        * platform/blackberry/PageClientBlackBerry.h:
+        * platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp:
+        (WebCore::MediaPlayerPrivate::MediaPlayerPrivate):
+        (WebCore::MediaPlayerPrivate::~MediaPlayerPrivate):
+        (WebCore::MediaPlayerPrivate::onAuthenticationNeeded):
+        (WebCore::MediaPlayerPrivate::notifyChallengeResult):
+        * platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.h:
+        (MediaPlayerPrivate):
+        * platform/network/blackberry/NetworkJob.cpp:
+        (WebCore::NetworkJob::NetworkJob):
+        (WebCore::NetworkJob::~NetworkJob):
+        (WebCore):
+        (WebCore::NetworkJob::handleNotifyStatusReceived):
+        (WebCore::NetworkJob::handleNotifyClose):
+        (WebCore::NetworkJob::sendRequestWithCredentials):
+        (WebCore::NetworkJob::notifyChallengeResult):
+        * platform/network/blackberry/NetworkJob.h:
+        (NetworkJob):
+
 2012-09-21  Simon Hausmann  <simon.hausmann@digia.com>
 
         Unreviewed, rolling out r129248.
index 53c2d35..1bcb5ce 100644 (file)
@@ -60,6 +60,7 @@ LIST(APPEND WebCore_SOURCES
     bindings/cpp/WebDOMString.cpp
     bindings/cpp/WebExceptionHandler.cpp
     platform/blackberry/CookieDatabaseBackingStore/CookieDatabaseBackingStore.cpp
+    platform/blackberry/AuthenticationChallengeManager.cpp
     platform/blackberry/CookieManager.cpp
     platform/blackberry/CookieMap.cpp
     platform/blackberry/CookieParser.cpp
diff --git a/Source/WebCore/platform/blackberry/AuthenticationChallengeManager.cpp b/Source/WebCore/platform/blackberry/AuthenticationChallengeManager.cpp
new file mode 100644 (file)
index 0000000..e40a42b
--- /dev/null
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "AuthenticationChallengeManager.h"
+
+#include "Credential.h"
+#include "KURL.h"
+#include "PageClientBlackBerry.h"
+#include "ProtectionSpace.h"
+
+#include <BlackBerryPlatformAssert.h>
+#include <BlackBerryPlatformLog.h>
+#include <wtf/Assertions.h>
+#include <wtf/HashMap.h>
+#include <wtf/Vector.h>
+#include <wtf/text/CString.h>
+
+namespace WebCore {
+
+typedef HashMap<PageClientBlackBerry*, bool> PageVisibilityMap;
+
+struct ChallengeInfo {
+    ChallengeInfo(const KURL&, const ProtectionSpace&, const Credential&, AuthenticationChallengeClient*, PageClientBlackBerry*);
+
+    KURL url;
+    ProtectionSpace space;
+    Credential credential;
+    AuthenticationChallengeClient* authClient;
+    PageClientBlackBerry* pageClient;
+    bool blocked;
+};
+
+ChallengeInfo::ChallengeInfo(const KURL& aUrl,
+                             const ProtectionSpace& aSpace,
+                             const Credential& aCredential,
+                             AuthenticationChallengeClient* anAuthClient,
+                             PageClientBlackBerry* aPageClient)
+    : url(aUrl)
+    , space(aSpace)
+    , credential(aCredential)
+    , authClient(anAuthClient)
+    , pageClient(aPageClient)
+    , blocked(false)
+{
+}
+
+class AuthenticationChallengeManagerPrivate {
+public:
+    AuthenticationChallengeManagerPrivate();
+
+    bool resumeAuthenticationChallenge(PageClientBlackBerry*);
+    void startAuthenticationChallenge(ChallengeInfo*);
+    bool pageExists(PageClientBlackBerry*);
+
+    ChallengeInfo* m_activeChallenge;
+    PageVisibilityMap m_pageVisibilityMap;
+    Vector<OwnPtr<ChallengeInfo> > m_challenges;
+};
+
+AuthenticationChallengeManagerPrivate::AuthenticationChallengeManagerPrivate()
+    : m_activeChallenge(0)
+{
+}
+
+bool AuthenticationChallengeManagerPrivate::resumeAuthenticationChallenge(PageClientBlackBerry* client)
+{
+    ASSERT(!m_activeChallenge);
+
+    for (size_t i = 0; i < m_challenges.size(); ++i) {
+        if (m_challenges[i]->pageClient == client && m_challenges[i]->blocked) {
+            startAuthenticationChallenge(m_challenges[i].get());
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void AuthenticationChallengeManagerPrivate::startAuthenticationChallenge(ChallengeInfo* info)
+{
+    m_activeChallenge = info;
+    m_activeChallenge->blocked = false;
+    m_activeChallenge->pageClient->authenticationChallenge(m_activeChallenge->url,
+                                                           m_activeChallenge->space,
+                                                           m_activeChallenge->credential);
+}
+
+bool AuthenticationChallengeManagerPrivate::pageExists(PageClientBlackBerry* client)
+{
+    return m_pageVisibilityMap.find(client) != m_pageVisibilityMap.end();
+}
+
+AuthenticationChallengeManager::AuthenticationChallengeManager()
+    : d(adoptPtr(new AuthenticationChallengeManagerPrivate))
+{
+}
+
+void AuthenticationChallengeManager::pageCreated(PageClientBlackBerry* client)
+{
+    d->m_pageVisibilityMap.add(client, true);
+}
+
+void AuthenticationChallengeManager::pageDeleted(PageClientBlackBerry* client)
+{
+    d->m_pageVisibilityMap.remove(client);
+
+    if (d->m_activeChallenge && d->m_activeChallenge->pageClient == client)
+        d->m_activeChallenge = 0;
+
+    Vector<OwnPtr<ChallengeInfo> > existing;
+    d->m_challenges.swap(existing);
+
+    for (size_t i = 0; i < existing.size(); ++i) {
+        if (existing[i]->pageClient != client)
+            d->m_challenges.append(existing[i].release());
+    }
+}
+
+void AuthenticationChallengeManager::pageVisibilityChanged(PageClientBlackBerry* client, bool visible)
+{
+    PageVisibilityMap::iterator iter = d->m_pageVisibilityMap.find(client);
+
+    ASSERT(iter != d->m_pageVisibilityMap.end());
+    if (iter == d->m_pageVisibilityMap.end()) {
+        d->m_pageVisibilityMap.add(client, visible);
+        return;
+    }
+
+    if (iter->second == visible)
+        return;
+
+    iter->second = visible;
+    if (!visible)
+        return;
+
+    if (d->m_activeChallenge)
+        return;
+
+    d->resumeAuthenticationChallenge(client);
+}
+
+void AuthenticationChallengeManager::authenticationChallenge(const KURL& url,
+                                                             const ProtectionSpace& space,
+                                                             const Credential& credential,
+                                                             AuthenticationChallengeClient* authClient,
+                                                             PageClientBlackBerry* pageClient)
+{
+    BLACKBERRY_ASSERT(authClient);
+    BLACKBERRY_ASSERT(pageClient);
+
+    ChallengeInfo* info = new ChallengeInfo(url, space, credential, authClient, pageClient);
+    d->m_challenges.append(adoptPtr(info));
+
+    if (d->m_activeChallenge || !pageClient->isVisible()) {
+        info->blocked = true;
+        return;
+    }
+
+    d->startAuthenticationChallenge(info);
+}
+
+void AuthenticationChallengeManager::cancelAuthenticationChallenge(AuthenticationChallengeClient* client)
+{
+    BLACKBERRY_ASSERT(client);
+
+    if (d->m_activeChallenge && d->m_activeChallenge->authClient == client)
+        d->m_activeChallenge = 0;
+
+    Vector<OwnPtr<ChallengeInfo> > existing;
+    d->m_challenges.swap(existing);
+
+    ChallengeInfo* next = 0;
+    PageClientBlackBerry* page = 0;
+
+    for (size_t i = 0; i < existing.size(); ++i) {
+        if (existing[i]->authClient != client) {
+            if (page && !next && existing[i]->pageClient == page)
+                next = existing[i].get();
+            d->m_challenges.append(existing[i].release());
+        } else if (d->m_activeChallenge == existing[i].get())
+            page = existing[i]->pageClient;
+    }
+
+    if (next)
+        d->startAuthenticationChallenge(next);
+}
+
+void AuthenticationChallengeManager::notifyChallengeResult(const KURL& url,
+                                                           const ProtectionSpace& space,
+                                                           AuthenticationChallengeResult result,
+                                                           const Credential& credential)
+{
+    d->m_activeChallenge = 0;
+
+    Vector<OwnPtr<ChallengeInfo> > existing;
+    d->m_challenges.swap(existing);
+
+    ChallengeInfo* next = 0;
+    PageClientBlackBerry* page = 0;
+
+    for (size_t i = 0; i < existing.size(); ++i) {
+        if (existing[i]->space != space) {
+            if (page && !next && existing[i]->pageClient == page)
+                next = existing[i].get();
+            d->m_challenges.append(existing[i].release());
+        } else {
+            page = existing[i]->pageClient;
+            existing[i]->authClient->notifyChallengeResult(existing[i]->url, space, result, credential);
+
+            // After calling notifyChallengeResult(), page could be destroyed or something.
+            if (!d->pageExists(page) || !page->isVisible())
+                page = 0;
+        }
+    }
+
+    if (next)
+        d->startAuthenticationChallenge(next);
+}
+
+// Keep following code at the end of this file!!!
+static AuthenticationChallengeManager* s_manager = 0;
+
+AuthenticationChallengeManager* AuthenticationChallengeManager::instance()
+{
+    ASSERT(s_manager);
+    return s_manager;
+}
+
+void AuthenticationChallengeManager::init()
+{
+    ASSERT(!s_manager);
+    s_manager = new AuthenticationChallengeManager();
+}
+
+// No more code after this line, all new code should come before s_manager declaration!!!
+
+} // namespace WebCore
index 52224f5..20e799b 100644 (file)
 #ifndef AuthenticationChallengeManager_h
 #define AuthenticationChallengeManager_h
 
+#include <wtf/OwnPtr.h>
+
+class PageClientBlackBerry;
+
 namespace WebCore {
 
+class AuthenticationChallengeManagerPrivate;
 class Credential;
 class KURL;
 class ProtectionSpace;
@@ -35,6 +40,36 @@ public:
     virtual void notifyChallengeResult(const KURL&, const ProtectionSpace&, AuthenticationChallengeResult, const Credential&) = 0;
 };
 
+class AuthenticationChallengeManager {
+public:
+    static void init();
+    static AuthenticationChallengeManager* instance();
+
+    void pageCreated(PageClientBlackBerry*);
+    void pageDeleted(PageClientBlackBerry*);
+    void pageVisibilityChanged(PageClientBlackBerry*, bool visible);
+
+    void authenticationChallenge(const KURL&,
+                                 const ProtectionSpace&,
+                                 const Credential&,
+                                 AuthenticationChallengeClient*,
+                                 PageClientBlackBerry*);
+
+    void cancelAuthenticationChallenge(AuthenticationChallengeClient*);
+
+    void notifyChallengeResult(const KURL&,
+                               const ProtectionSpace&,
+                               AuthenticationChallengeResult,
+                               const Credential&);
+
+private:
+    AuthenticationChallengeManager();
+    ~AuthenticationChallengeManager();
+
+    OwnPtr<AuthenticationChallengeManagerPrivate> d;
+};
+
+
 } // namespace WebCore
 
 #endif // AuthenticationChallengeManager_h
index bdb2f16..f2c7c0e 100644 (file)
@@ -72,7 +72,7 @@ public:
     virtual int showAlertDialog(BlackBerry::WebKit::WebPageClient::AlertType) = 0;
     virtual bool isActive() const = 0;
     virtual bool isVisible() const = 0;
-    virtual void authenticationChallenge(const WebCore::KURL&, const WebCore::ProtectionSpace&, const WebCore::Credential&, WebCore::AuthenticationChallengeClient*) = 0;
+    virtual void authenticationChallenge(const WebCore::KURL&, const WebCore::ProtectionSpace&, const WebCore::Credential&) = 0;
     virtual SaveCredentialType notifyShouldSaveCredential(bool) = 0;
     virtual void syncProxyCredential(const WebCore::Credential&) = 0;
 };
index af06a23..d696ad1 100644 (file)
@@ -21,6 +21,7 @@
 #if ENABLE(VIDEO)
 #include "MediaPlayerPrivateBlackBerry.h"
 
+#include "AuthenticationChallengeManager.h"
 #include "CookieManager.h"
 #include "Credential.h"
 #include "CredentialStorage.h"
@@ -114,6 +115,7 @@ MediaPlayerPrivate::MediaPlayerPrivate(MediaPlayer* player)
     , m_userDrivenSeekTimer(this, &MediaPlayerPrivate::userDrivenSeekTimerFired)
     , m_lastSeekTime(0)
     , m_lastSeekTimePending(false)
+    , m_isAuthenticationChallenging(false)
     , m_waitMetadataTimer(this, &MediaPlayerPrivate::waitMetadataTimerFired)
     , m_waitMetadataPopDialogCounter(0)
 {
@@ -121,6 +123,9 @@ MediaPlayerPrivate::MediaPlayerPrivate(MediaPlayer* player)
 
 MediaPlayerPrivate::~MediaPlayerPrivate()
 {
+    if (m_isAuthenticationChallenging)
+        AuthenticationChallengeManager::instance()->cancelAuthenticationChallenge(this);
+
     if (isFullscreen()) {
         m_webCorePlayer->mediaPlayerClient()->mediaPlayerExitFullscreen();
     }
@@ -710,12 +715,18 @@ void MediaPlayerPrivate::onAuthenticationNeeded(MMRAuthChallenge& authChallenge)
         return;
     }
 
-    if (frameView() && frameView()->hostWindow())
-        frameView()->hostWindow()->platformPageClient()->authenticationChallenge(url, protectionSpace, credential, this);
+    m_isAuthenticationChallenging = true;
+    AuthenticationChallengeManager::instance()->authenticationChallenge(url,
+                                                                        protectionSpace,
+                                                                        credential,
+                                                                        this,
+                                                                        m_webCorePlayer->mediaPlayerClient()->mediaPlayerHostWindow()->platformPageClient());
 }
 
 void MediaPlayerPrivate::notifyChallengeResult(const KURL& url, const ProtectionSpace& protectionSpace, AuthenticationChallengeResult result, const Credential& credential)
 {
+    m_isAuthenticationChallenging = false;
+
     if (result != AuthenticationChallengeSuccess || !url.isValid())
         return;
 
index 2896692..5a083b5 100644 (file)
@@ -174,6 +174,7 @@ private:
     Timer<MediaPlayerPrivate> m_userDrivenSeekTimer;
     float m_lastSeekTime;
     bool m_lastSeekTimePending;
+    bool m_isAuthenticationChallenging;
     void waitMetadataTimerFired(Timer<MediaPlayerPrivate>*);
     Timer<MediaPlayerPrivate> m_waitMetadataTimer;
     int m_waitMetadataPopDialogCounter;
index 98ebe60..cca89b5 100644 (file)
@@ -19,6 +19,7 @@
 #include "config.h"
 #include "NetworkJob.h"
 
+#include "AuthenticationChallengeManager.h"
 #include "Chrome.h"
 #include "ChromeClient.h"
 #include "CookieManager.h"
@@ -84,9 +85,16 @@ NetworkJob::NetworkJob()
     , m_deferredData(*this)
     , m_deferLoadingCount(0)
     , m_frame(0)
+    , m_isAuthenticationChallenging(false)
 {
 }
 
+NetworkJob::~NetworkJob()
+{
+    if (m_isAuthenticationChallenging)
+        AuthenticationChallengeManager::instance()->cancelAuthenticationChallenge(this);
+}
+
 bool NetworkJob::initialize(int playerId,
                             const String& pageGroupName,
                             const KURL& url,
@@ -203,10 +211,8 @@ void NetworkJob::handleNotifyStatusReceived(int status, const String& message)
 
     m_response.setHTTPStatusText(message);
 
-    if (isUnauthorized(m_extendedStatusCode)) {
+    if (isUnauthorized(m_extendedStatusCode))
         purgeCredentials();
-        BlackBerry::Platform::log(BlackBerry::Platform::LogLevelCritical, "Authentication failed, purge the stored credentials for this site.");
-    }
 }
 
 void NetworkJob::notifyHeadersReceived(BlackBerry::Platform::NetworkRequest::HeaderList& headers)
@@ -484,6 +490,7 @@ void NetworkJob::handleNotifyClose(int status)
 #ifndef NDEBUG
     m_isRunning = false;
 #endif
+
     if (!m_cancelled) {
         if (!m_statusReceived) {
             // Connection failed before sending notifyStatusReceived: use generic NetworkError.
@@ -495,6 +502,7 @@ void NetworkJob::handleNotifyClose(int status)
                 m_extendedStatusCode = BlackBerry::Platform::FilterStream::StatusTooManyRedirects;
 
             sendResponseIfNeeded();
+
             if (isClientAvailable()) {
                 if (isError(status))
                     m_extendedStatusCode = status;
@@ -767,7 +775,15 @@ bool NetworkJob::sendRequestWithCredentials(ProtectionSpaceServerType type, Prot
                 return false;
 
             m_handle->getInternal()->m_currentWebChallenge = AuthenticationChallenge();
-            m_frame->page()->chrome()->client()->platformPageClient()->authenticationChallenge(newURL, protectionSpace, Credential(), this);
+
+            m_isAuthenticationChallenging = true;
+            updateDeferLoadingCount(1);
+
+            AuthenticationChallengeManager::instance()->authenticationChallenge(newURL,
+                                                                                protectionSpace,
+                                                                                Credential(),
+                                                                                this,
+                                                                                m_frame->page()->chrome()->client()->platformPageClient());
             return true;
         }
 
@@ -828,11 +844,17 @@ void NetworkJob::fireDeleteJobTimer(Timer<NetworkJob>*)
 
 void NetworkJob::notifyChallengeResult(const KURL& url, const ProtectionSpace& protectionSpace, AuthenticationChallengeResult result, const Credential& credential)
 {
+    m_isAuthenticationChallenging = false;
+
     if (result != AuthenticationChallengeSuccess || protectionSpace.host().isEmpty() || !url.isValid()) {
         m_newJobWithCredentialsStarted = false;
+        updateDeferLoadingCount(-1);
         return;
     }
 
+    cancelJob();
+    updateDeferLoadingCount(-1);
+
     if (m_handle->getInternal()->m_currentWebChallenge.isNull())
         m_handle->getInternal()->m_currentWebChallenge = AuthenticationChallenge(protectionSpace, credential, 0, m_response, ResourceError());
 
index 3526374..8bfb467 100644 (file)
@@ -29,6 +29,7 @@
 #include <network/FilterStream.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/RefPtr.h>
+#include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
 
 namespace BlackBerry {
@@ -49,6 +50,8 @@ class ResourceRequest;
 class NetworkJob : public AuthenticationChallengeClient, public BlackBerry::Platform::FilterStream {
 public:
     NetworkJob();
+    ~NetworkJob();
+
     bool initialize(int playerId,
                     const String& pageGroupName,
                     const KURL&,
@@ -171,6 +174,8 @@ private:
     DeferredData m_deferredData;
     int m_deferLoadingCount;
     const Frame* m_frame;
+
+    bool m_isAuthenticationChallenging;
 };
 
 } // namespace WebCore
index fc9cd5a..d8b5c51 100644 (file)
@@ -20,6 +20,7 @@
 #include "BlackBerryGlobal.h"
 
 #include "ApplicationCacheStorage.h"
+#include "AuthenticationChallengeManager.h"
 #include "CacheClientBlackBerry.h"
 #include "CookieManager.h"
 #include "CrossOriginPreflightResultCache.h"
@@ -80,6 +81,8 @@ void globalInitialize()
     BlackBerry::Platform::Settings* settings = BlackBerry::Platform::Settings::instance();
 
     ImageSource::setMaxPixelsPerDecodedImage(settings->maxPixelsPerDecodedImage());
+
+    AuthenticationChallengeManager::init();
 }
 
 void collectJavascriptGarbageNow()
index 2326dbf..1280757 100644 (file)
@@ -427,6 +427,8 @@ WebPagePrivate::WebPagePrivate(WebPage* webPage, WebPageClient* client, const In
         BlackBerry::Platform::DeviceInfo::instance();
         defaultUserAgent();
     }
+
+    AuthenticationChallengeManager::instance()->pageCreated(this);
 }
 
 WebPage::WebPage(WebPageClient* client, const WebString& pageGroupName, const Platform::IntRect& rect)
@@ -438,6 +440,7 @@ WebPage::WebPage(WebPageClient* client, const WebString& pageGroupName, const Pl
 
 WebPagePrivate::~WebPagePrivate()
 {
+    AuthenticationChallengeManager::instance()->pageDeleted(this);
     // Hand the backingstore back to another owner if necessary.
     m_webPage->setVisible(false);
     if (BackingStorePrivate::currentBackingStoreOwner() == m_webPage)
@@ -2210,18 +2213,19 @@ bool WebPagePrivate::isActive() const
     return m_client->isActive();
 }
 
-void WebPagePrivate::authenticationChallenge(const KURL& url, const ProtectionSpace& protectionSpace, const Credential& inputCredential, AuthenticationChallengeClient* client)
+void WebPagePrivate::authenticationChallenge(const KURL& url, const ProtectionSpace& protectionSpace, const Credential& inputCredential)
 {
     WebString username;
     WebString password;
+    AuthenticationChallengeManager* authmgr = AuthenticationChallengeManager::instance();
 
 #if !defined(PUBLIC_BUILD) || !PUBLIC_BUILD
     if (m_dumpRenderTree) {
         Credential credential(inputCredential, inputCredential.persistence());
         if (m_dumpRenderTree->didReceiveAuthenticationChallenge(credential))
-            client->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeSuccess, credential);
+            authmgr->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeSuccess, credential);
         else
-            client->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeCancelled, inputCredential);
+            authmgr->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeCancelled, inputCredential);
         return;
     }
 #endif
@@ -2242,9 +2246,9 @@ void WebPagePrivate::authenticationChallenge(const KURL& url, const ProtectionSp
 #endif
 
     if (isConfirmed)
-        client->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeSuccess, credential);
+        authmgr->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeSuccess, credential);
     else
-        client->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeCancelled, inputCredential);
+        authmgr->notifyChallengeResult(url, protectionSpace, AuthenticationChallengeCancelled, inputCredential);
 }
 
 PageClientBlackBerry::SaveCredentialType WebPagePrivate::notifyShouldSaveCredential(bool isNew)
@@ -3236,6 +3240,7 @@ void WebPage::setVisible(bool visible)
         return;
 
     d->setVisible(visible);
+    AuthenticationChallengeManager::instance()->pageVisibilityChanged(d, visible);
 
     if (!visible) {
         d->suspendBackingStore();
index 7c226f3..bcb7d50 100644 (file)
@@ -201,7 +201,7 @@ public:
     virtual int showAlertDialog(WebPageClient::AlertType atype);
     virtual bool isActive() const;
     virtual bool isVisible() const { return m_visible; }
-    virtual void authenticationChallenge(const WebCore::KURL&, const WebCore::ProtectionSpace&, const WebCore::Credential&, WebCore::AuthenticationChallengeClient*);
+    virtual void authenticationChallenge(const WebCore::KURL&, const WebCore::ProtectionSpace&, const WebCore::Credential&);
     virtual SaveCredentialType notifyShouldSaveCredential(bool);
     virtual void syncProxyCredential(const WebCore::Credential&);
 
index 5cc5410..ed56878 100644 (file)
@@ -1,3 +1,27 @@
+2012-09-21  Lianghui Chen  <liachen@rim.com>
+
+        [BlackBerry] Really fix bug 95488 that user can get the authentication challenge dialog while the other tab has focus.
+        https://bugs.webkit.org/show_bug.cgi?id=97348
+        Internal PR: 186597.
+
+        Internally reviewed by Yong Li, Joe Mason.
+        Reviewed by Yong Li.
+
+        Update WebPage to use new AuthenticationChallengeManager.
+        Register page creation/deletion and visibility change to the new
+            AuthenticationChallengeManager.
+        Initialize AuthenticationChallengeManager in GlobalInitialize() function.
+
+        * Api/BlackBerryGlobal.cpp:
+        (BlackBerry::WebKit::globalInitialize):
+        * Api/WebPage.cpp:
+        (BlackBerry::WebKit::WebPagePrivate::WebPagePrivate):
+        (BlackBerry::WebKit::WebPagePrivate::~WebPagePrivate):
+        (BlackBerry::WebKit::WebPagePrivate::authenticationChallenge):
+        (BlackBerry::WebKit::WebPage::setVisible):
+        * Api/WebPage_p.h:
+        (WebPagePrivate):
+
 2012-09-21  Charles Wei  <charles.wei@torchmobile.com.cn>
 
         Wrong seperator for viewport meta in Popup scripts