Changeset 162568 in webkit


Ignore:
Timestamp:
Jan 22, 2014 4:28:20 PM (10 years ago)
Author:
commit-queue@webkit.org
Message:

Enable Session API.
​https://bugs.webkit.org/show_bug.cgi?id=127255

Patch by Martin Hock <​mhock@apple.com> on 2014-01-22
Reviewed by Alexey Proskuryakov.

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::storageSession):

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::NetworkResourceLoader):
(WebKit::NetworkResourceLoader::start):

  • NetworkProcess/NetworkResourceLoader.h:
  • NetworkProcess/RemoteNetworkingContext.h:
  • NetworkProcess/mac/RemoteNetworkingContext.mm:

(WebKit::RemoteNetworkingContext::storageSession):
(WebKit::RemoteNetworkingContext::ensurePrivateBrowsingSession):

  • Shared/Network/NetworkResourceLoadParameters.cpp:

(WebKit::NetworkResourceLoadParameters::NetworkResourceLoadParameters):
(WebKit::NetworkResourceLoadParameters::encode):
(WebKit::NetworkResourceLoadParameters::decode):

  • Shared/Network/NetworkResourceLoadParameters.h:
  • Shared/SessionTracker.cpp:

(WebKit::staticSessionMap):
(WebKit::SessionTracker::sessionMap):
(WebKit::SessionTracker::session):
(WebKit::SessionTracker::setSession):
(WebKit::SessionTracker::destroySession):

  • Shared/SessionTracker.h:
  • UIProcess/API/C/WKPage.cpp:

(WKPageSetSession):

  • UIProcess/API/C/WKPage.h:
  • UIProcess/API/C/WKSessionRef.cpp:

(WKSessionCreate):

  • UIProcess/API/C/WKSessionRef.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::WebPageProxy):
(WebKit::WebPageProxy::setSession):

  • UIProcess/WebPageProxy.h:
  • WebProcess/Network/WebResourceLoadScheduler.cpp:

(WebKit::WebResourceLoadScheduler::scheduleLoad):

  • WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:

(WebKit::WebPlatformStrategies::loadResourceSynchronously):

  • WebProcess/WebCoreSupport/mac/WebFrameNetworkingContext.mm:

(WebKit::WebFrameNetworkingContext::ensurePrivateBrowsingSession):
(WebKit::WebFrameNetworkingContext::setCookieAcceptPolicyForAllContexts):
(WebKit::WebFrameNetworkingContext::storageSession):

  • WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp:

(WebKit::WebFrameNetworkingContext::ensurePrivateBrowsingSession):

  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::startDownload):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::WebPage):
(WebKit::WebPage::sessionID):
(WebKit::WebPage::updatePreferences):

  • WebProcess/WebPage/WebPage.h:

(WebKit::WebPage::setSessionID):

  • WebProcess/WebPage/WebPage.messages.in:
Location:
trunk/Source/WebKit2
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r162566 r162568  
     12014-01-22  Martin Hock  <mhock@apple.com>
     2
     3        Enable Session API.
     4        https://bugs.webkit.org/show_bug.cgi?id=127255
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     9        (WebKit::storageSession):
     10        * NetworkProcess/NetworkResourceLoader.cpp:
     11        (WebKit::NetworkResourceLoader::NetworkResourceLoader):
     12        (WebKit::NetworkResourceLoader::start):
     13        * NetworkProcess/NetworkResourceLoader.h:
     14        * NetworkProcess/RemoteNetworkingContext.h:
     15        * NetworkProcess/mac/RemoteNetworkingContext.mm:
     16        (WebKit::RemoteNetworkingContext::storageSession):
     17        (WebKit::RemoteNetworkingContext::ensurePrivateBrowsingSession):
     18        * Shared/Network/NetworkResourceLoadParameters.cpp:
     19        (WebKit::NetworkResourceLoadParameters::NetworkResourceLoadParameters):
     20        (WebKit::NetworkResourceLoadParameters::encode):
     21        (WebKit::NetworkResourceLoadParameters::decode):
     22        * Shared/Network/NetworkResourceLoadParameters.h:
     23        * Shared/SessionTracker.cpp:
     24        (WebKit::staticSessionMap):
     25        (WebKit::SessionTracker::sessionMap):
     26        (WebKit::SessionTracker::session):
     27        (WebKit::SessionTracker::setSession):
     28        (WebKit::SessionTracker::destroySession):
     29        * Shared/SessionTracker.h:
     30        * UIProcess/API/C/WKPage.cpp:
     31        (WKPageSetSession):
     32        * UIProcess/API/C/WKPage.h:
     33        * UIProcess/API/C/WKSessionRef.cpp:
     34        (WKSessionCreate):
     35        * UIProcess/API/C/WKSessionRef.h:
     36        * UIProcess/WebPageProxy.cpp:
     37        (WebKit::WebPageProxy::WebPageProxy):
     38        (WebKit::WebPageProxy::setSession):
     39        * UIProcess/WebPageProxy.h:
     40        * WebProcess/Network/WebResourceLoadScheduler.cpp:
     41        (WebKit::WebResourceLoadScheduler::scheduleLoad):
     42        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
     43        (WebKit::WebPlatformStrategies::loadResourceSynchronously):
     44        * WebProcess/WebCoreSupport/mac/WebFrameNetworkingContext.mm:
     45        (WebKit::WebFrameNetworkingContext::ensurePrivateBrowsingSession):
     46        (WebKit::WebFrameNetworkingContext::setCookieAcceptPolicyForAllContexts):
     47        (WebKit::WebFrameNetworkingContext::storageSession):
     48        * WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp:
     49        (WebKit::WebFrameNetworkingContext::ensurePrivateBrowsingSession):
     50        * WebProcess/WebPage/WebFrame.cpp:
     51        (WebKit::WebFrame::startDownload):
     52        * WebProcess/WebPage/WebPage.cpp:
     53        (WebKit::WebPage::WebPage):
     54        (WebKit::WebPage::sessionID):
     55        (WebKit::WebPage::updatePreferences):
     56        * WebProcess/WebPage/WebPage.h:
     57        (WebKit::WebPage::setSessionID):
     58        * WebProcess/WebPage/WebPage.messages.in:
     59
    1602014-01-21  Brady Eidson  <beidson@apple.com>
    261

  • trunk/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r162271 r162568  
    152152{
    153153    if (SessionTracker::isEphemeralID(sessionID)) {
    154         NetworkStorageSession* privateSession = SessionTracker::session(sessionID).get();
     154        NetworkStorageSession* privateSession = SessionTracker::session(sessionID);
    155155        if (privateSession)
    156156            return *privateSession;

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r161950 r162568  
    6060    , m_webPageID(parameters.webPageID)
    6161    , m_webFrameID(parameters.webFrameID)
     62    , m_sessionID(parameters.sessionID)
    6263    , m_request(parameters.request)
    6364    , m_priority(parameters.priority)
    … …  
    6566    , m_allowStoredCredentials(parameters.allowStoredCredentials)
    6667    , m_clientCredentialPolicy(parameters.clientCredentialPolicy)
    67     , m_inPrivateBrowsingMode(parameters.inPrivateBrowsingMode)
    6868    , m_shouldClearReferrerOnHTTPSToHTTPRedirect(parameters.shouldClearReferrerOnHTTPSToHTTPRedirect)
    6969    , m_isLoadingMainResource(parameters.isMainResource)
    … …  
    128128
    129129    // FIXME (NetworkProcess): Set platform specific settings.
    130     m_networkingContext = RemoteNetworkingContext::create(m_inPrivateBrowsingMode, m_shouldClearReferrerOnHTTPSToHTTPRedirect);
     130    m_networkingContext = RemoteNetworkingContext::create(m_sessionID, m_shouldClearReferrerOnHTTPSToHTTPRedirect);
    131131
    132132    consumeSandboxExtensions();

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r162139 r162568  
    175175    uint64_t m_webPageID;
    176176    uint64_t m_webFrameID;
     177    uint64_t m_sessionID;
    177178    WebCore::ResourceRequest m_request;
    178179    WebCore::ResourceLoadPriority m_priority;
    … …  
    180181    WebCore::StoredCredentials m_allowStoredCredentials;
    181182    WebCore::ClientCredentialPolicy m_clientCredentialPolicy;
    182     bool m_inPrivateBrowsingMode;
    183183    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
    184184    bool m_isLoadingMainResource;

  • trunk/Source/WebKit2/NetworkProcess/RemoteNetworkingContext.h

    r162271 r162568  
    3434class RemoteNetworkingContext final : public WebCore::NetworkingContext {
    3535public:
    36     static PassRefPtr<RemoteNetworkingContext> create(bool privateBrowsingEnabled, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
     36    static PassRefPtr<RemoteNetworkingContext> create(uint64_t sessionID, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
    3737    {
    38         return adoptRef(new RemoteNetworkingContext(privateBrowsingEnabled, shouldClearReferrerOnHTTPSToHTTPRedirect));
     38        return adoptRef(new RemoteNetworkingContext(sessionID, shouldClearReferrerOnHTTPSToHTTPRedirect));
    3939    }
    4040    virtual ~RemoteNetworkingContext();
    4141
    42     // FIXME: remove platform-specific code and use SessionTracker
     42    // FIXME: Remove platform-specific code and use SessionTracker.
    4343    static void ensurePrivateBrowsingSession(uint64_t sessionID);
    4444
    … …  
    4646
    4747private:
    48     RemoteNetworkingContext(bool privateBrowsingEnabled, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
    49         : m_privateBrowsingEnabled(privateBrowsingEnabled)
     48    RemoteNetworkingContext(uint64_t sessionID, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
     49        : m_sessionID(sessionID)
    5050        , m_shouldClearReferrerOnHTTPSToHTTPRedirect(shouldClearReferrerOnHTTPSToHTTPRedirect)
    5151#if PLATFORM(MAC)
    … …  
    7171#endif
    7272
    73     bool m_privateBrowsingEnabled;
     73    uint64_t m_sessionID;
    7474    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
    7575

  • trunk/Source/WebKit2/NetworkProcess/mac/RemoteNetworkingContext.mm

    r162271 r162568  
    6060NetworkStorageSession& RemoteNetworkingContext::storageSession() const
    6161{
    62     if (m_privateBrowsingEnabled) {
    63         NetworkStorageSession* privateSession = SessionTracker::session(SessionTracker::legacyPrivateSessionID).get();
    64         if (privateSession)
    65             return *privateSession;
    66         // Some requests with private browsing mode requested may still be coming shortly after NetworkProcess was told to destroy its session.
    67         // FIXME: Find a way to track private browsing sessions more rigorously.
    68         LOG_ERROR("Private browsing was requested, but there was no session for it. Please file a bug unless you just disabled private browsing, in which case it's an expected race.");
    69     }
    70 
     62    NetworkStorageSession* session = SessionTracker::session(m_sessionID);
     63    if (session)
     64        return *session;
     65    // Some requests may still be coming shortly after NetworkProcess was told to destroy its session.
     66    LOG_ERROR("Invalid session ID. Please file a bug unless you just disabled private browsing, in which case it's an expected race.");
    7167    return NetworkStorageSession::defaultStorageSession();
    7268}
    … …  
    8884
    8985    ASSERT(!SessionTracker::getIdentifierBase().isNull());
    90     SessionTracker::session(sessionID) = NetworkStorageSession::createPrivateBrowsingSession(SessionTracker::getIdentifierBase() + '.' + String::number(sessionID));
     86    SessionTracker::setSession(sessionID, NetworkStorageSession::createPrivateBrowsingSession(SessionTracker::getIdentifierBase() + '.' + String::number(sessionID)));
    9187}
    9288

  • trunk/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp

    r161148 r162568  
    4242    , webPageID(0)
    4343    , webFrameID(0)
     44    , sessionID(0)
    4445    , priority(ResourceLoadPriorityVeryLow)
    4546    , contentSniffingPolicy(SniffContent)
    4647    , allowStoredCredentials(DoNotAllowStoredCredentials)
    4748    , clientCredentialPolicy(DoNotAskClientForAnyCredentials)
    48     , inPrivateBrowsingMode(false)
    4949    , shouldClearReferrerOnHTTPSToHTTPRedirect(true)
    5050    , isMainResource(false)
    … …  
    5757    encoder << webPageID;
    5858    encoder << webFrameID;
     59    encoder << sessionID;
    5960    encoder << request;
    6061
    … …  
    9596    encoder.encodeEnum(allowStoredCredentials);
    9697    encoder.encodeEnum(clientCredentialPolicy);
    97     encoder << inPrivateBrowsingMode;
    9898    encoder << shouldClearReferrerOnHTTPSToHTTPRedirect;
    9999    encoder << isMainResource;
    … …  
    109109
    110110    if (!decoder.decode(result.webFrameID))
     111        return false;
     112
     113    if (!decoder.decode(result.sessionID))
    111114        return false;
    112115
    … …  
    142145    if (!decoder.decodeEnum(result.clientCredentialPolicy))
    143146        return false;
    144     if (!decoder.decode(result.inPrivateBrowsingMode))
    145         return false;
    146147    if (!decoder.decode(result.shouldClearReferrerOnHTTPSToHTTPRedirect))
    147148        return false;

  • trunk/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h

    r161148 r162568  
    5353    uint64_t webPageID;
    5454    uint64_t webFrameID;
     55    uint64_t sessionID;
    5556    WebCore::ResourceRequest request;
    5657    SandboxExtension::HandleArray requestBodySandboxExtensions; // Created automatically for the sender.
    … …  
    6061    WebCore::StoredCredentials allowStoredCredentials;
    6162    WebCore::ClientCredentialPolicy clientCredentialPolicy;
    62     bool inPrivateBrowsingMode;
    6363    bool shouldClearReferrerOnHTTPSToHTTPRedirect;
    6464    bool isMainResource;

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

    r162271 r162568  
    3434namespace WebKit {
    3535
    36 static HashMap<uint64_t, std::unique_ptr<NetworkStorageSession>>& sessionMap()
     36static HashMap<uint64_t, std::unique_ptr<NetworkStorageSession>>& staticSessionMap()
    3737{
    3838    ASSERT(isMainThread());
    … …  
    5050}
    5151
    52 const HashMap<uint64_t, std::unique_ptr<NetworkStorageSession>>& SessionTracker::getSessionMap()
     52const HashMap<uint64_t, std::unique_ptr<NetworkStorageSession>>& SessionTracker::sessionMap()
    5353{
    54     return sessionMap();
     54    return staticSessionMap();
    5555}
    5656
    … …  
    6060}
    6161
    62 std::unique_ptr<NetworkStorageSession>& SessionTracker::session(uint64_t sessionID)
     62NetworkStorageSession* SessionTracker::session(uint64_t sessionID)
    6363{
    64     return sessionMap().add(sessionID, nullptr).iterator->value;
     64    if (sessionID == defaultSessionID)
     65        return &NetworkStorageSession::defaultStorageSession();
     66    return staticSessionMap().add(sessionID, nullptr).iterator->value.get();
     67}
     68
     69void SessionTracker::setSession(uint64_t sessionID, std::unique_ptr<NetworkStorageSession> session)
     70{
     71    ASSERT(sessionID != defaultSessionID);
     72    staticSessionMap().add(sessionID, nullptr).iterator->value = std::move(session);
    6573}
    6674
    … …  
    6977    ASSERT(isMainThread());
    7078
    71     sessionMap().remove(sessionID);
     79    staticSessionMap().remove(sessionID);
    7280}
    7381

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

    r162271 r162568  
    4040    static const uint64_t legacyPrivateSessionID = 2;
    4141    static bool isEphemeralID(uint64_t sessionID) { return sessionID != SessionTracker::defaultSessionID; }
    42     static const HashMap<uint64_t, std::unique_ptr<WebCore::NetworkStorageSession>>& getSessionMap();
     42    // FIXME: sessionMap()'s returned map does not include default session.
     43    static const HashMap<uint64_t, std::unique_ptr<WebCore::NetworkStorageSession>>& sessionMap();
    4344    static const String& getIdentifierBase();
    44     static std::unique_ptr<WebCore::NetworkStorageSession>& session(uint64_t sessionID);
     45    static WebCore::NetworkStorageSession* session(uint64_t sessionID);
     46    static void setSession(uint64_t sessionID, std::unique_ptr<WebCore::NetworkStorageSession>);
    4547    static void destroySession(uint64_t sessionID);
    4648    static void setIdentifierBase(const String&);

  • trunk/Source/WebKit2/UIProcess/API/C/WKPage.cpp

    r161105 r162568  
    681681}
    682682
     683void WKPageSetSession(WKPageRef pageRef, WKSessionRef session)
     684{
     685    toImpl(pageRef)->setSession(*toImpl(session));
     686}
     687
    683688void WKPageRunJavaScriptInMainFrame(WKPageRef pageRef, WKStringRef scriptRef, void* context, WKPageRunJavaScriptFunction callback)
    684689{

  • trunk/Source/WebKit2/UIProcess/API/C/WKPage.h

    r160385 r162568  
    4242#include <WebKit2/WKPageUIClient.h>
    4343#include <WebKit2/WKPageVisibilityTypes.h>
     44#include <WebKit2/WKSessionRef.h>
    4445
    4546#ifndef __cplusplus
    … …  
    202203WK_EXPORT void WKPageSetPageUIClient(WKPageRef page, const WKPageUIClientBase* client);
    203204
     205WK_EXPORT void WKPageSetSession(WKPageRef page, WKSessionRef session);
     206
    204207typedef void (*WKPageRunJavaScriptFunction)(WKSerializedScriptValueRef, WKErrorRef, void*);
    205208WK_EXPORT void WKPageRunJavaScriptInMainFrame(WKPageRef page, WKStringRef script, void* context, WKPageRunJavaScriptFunction function);

  • trunk/Source/WebKit2/UIProcess/API/C/WKSessionRef.cpp

    r162465 r162568  
    3232using namespace WebKit;
    3333
     34WKSessionRef WKSessionCreate(bool isEphemeral)
     35{
     36    RefPtr<API::Session> session = API::Session::create(isEphemeral);
     37    return toAPI(session.release().leakRef());
     38}
     39
    3440WKTypeID WKSessionGetTypeID()
    3541{

  • trunk/Source/WebKit2/UIProcess/API/C/WKSessionRef.h

    r162465 r162568  
    3333#endif
    3434
     35/* FIXME: We can create sessions on demand, because we hardcode the fact that all sessions but the default one are ephemeral. We'll need to create them explicitly once sessions have more configuration options. */
     36WK_EXPORT WKSessionRef WKSessionCreate(bool isEphemeral);
     37
    3538WK_EXPORT WKTypeID WKSessionGetTypeID();
    3639

  • trunk/Source/WebKit2/UIProcess/APISession.h

    r162271 r162568  
    3535class Session : public API::ObjectImpl<API::Object::Type::Session> {
    3636public:
     37    // FIXME: We can create sessions on demand, because we hardcode the fact that all sessions but the default one are ephemeral. We'll need to create them explicitly once sessions have more configuration options.
    3738    static PassRefPtr<Session> create(bool isEphemeral);
    3839    static Session& defaultSession();

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r162449 r162568  
    119119#endif
    120120
     121#if ENABLE(NETWORK_PROCESS)
     122#include "NetworkProcessMessages.h"
     123#endif
     124
    121125// This controls what strategy we use for mouse wheel coalescing.
    122126#define MERGE_WHEEL_EVENTS 1
    … …  
    342346    // FIXME: If we ever expose the session storage size as a preference, we need to pass it here.
    343347    m_process->context().storageManager().createSessionStorageNamespace(m_pageID, m_process->isValid() ? m_process->connection() : 0, std::numeric_limits<unsigned>::max());
     348    setSession(session);
    344349}
    345350
    … …  
    496501    m_process->send(Messages::WebPage::GoToBackForwardItem(item->itemID()), m_pageID);
    497502    m_process->responsivenessTimer()->start();
     503}
     504
     505void WebPageProxy::setSession(API::Session& session)
     506{
     507    m_session = session;
     508    m_process->send(Messages::WebPage::SetSessionID(session.getID()), m_pageID);
     509
     510#if ENABLE(NETWORK_PROCESS)
     511    m_process->context().sendToNetworkingProcess(Messages::NetworkProcess::EnsurePrivateBrowsingSession(session.getID()));
     512#endif
    498513}
    499514

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r162449 r162568  
    333333    virtual ~WebPageProxy();
    334334
     335    void setSession(API::Session&);
     336
    335337    uint64_t pageID() const { return m_pageID; }
    336338    uint64_t sessionID() const { return m_session->getID(); }

  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp

    r156550 r162568  
    3131#include "NetworkProcessConnection.h"
    3232#include "NetworkResourceLoadParameters.h"
     33#include "SessionTracker.h"
    3334#include "WebCoreArgumentCoders.h"
    3435#include "WebErrors.h"
    … …  
    106107    ContentSniffingPolicy contentSniffingPolicy = resourceLoader->shouldSniffContent() ? SniffContent : DoNotSniffContent;
    107108    StoredCredentials allowStoredCredentials = resourceLoader->shouldUseCredentialStorage() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
    108     bool privateBrowsingEnabled = resourceLoader->frameLoader()->frame().settings().privateBrowsingEnabled();
    109109
    110110    // FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
    … …  
    119119    loadParameters.webPageID = webPage ? webPage->pageID() : 0;
    120120    loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
     121    loadParameters.sessionID = webPage ? webPage->sessionID() : SessionTracker::defaultSessionID;
    121122    loadParameters.request = resourceLoader->request();
    122123    loadParameters.priority = priority;
    … …  
    125126    // If there is no WebFrame then this resource cannot be authenticated with the client.
    126127    loadParameters.clientCredentialPolicy = (webFrame && webPage) ? resourceLoader->clientCredentialPolicy() : DoNotAskClientForAnyCredentials;
    127     loadParameters.inPrivateBrowsingMode = privateBrowsingEnabled;
    128128    loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
    129129    loadParameters.isMainResource = resource && resource->type() == CachedResource::MainResource;

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp

    r162271 r162568  
    271271    loadParameters.webPageID = webPage ? webPage->pageID() : 0;
    272272    loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
     273    loadParameters.sessionID = webPage ? webPage->sessionID() : SessionTracker::defaultSessionID;
    273274    loadParameters.request = request;
    274275    loadParameters.priority = ResourceLoadPriorityHighest;
    … …  
    276277    loadParameters.allowStoredCredentials = storedCredentials;
    277278    loadParameters.clientCredentialPolicy = clientCredentialPolicy;
    278     loadParameters.inPrivateBrowsingMode = context->storageSession().isPrivateBrowsingSession();
    279279    loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = context->shouldClearReferrerOnHTTPSToHTTPRedirect();
    280280

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/mac/WebFrameNetworkingContext.mm

    r162271 r162568  
    2929#include "WebCookieManager.h"
    3030#include "WebFrameNetworkingContext.h"
     31#include "WebPage.h"
    3132#include <WebCore/Frame.h>
    3233#include <WebCore/FrameLoader.h>
    … …  
    5354        base = SessionTracker::getIdentifierBase();
    5455
    55     SessionTracker::session(sessionID) = NetworkStorageSession::createPrivateBrowsingSession(base + '.' + String::number(sessionID));
     56    SessionTracker::setSession(sessionID, NetworkStorageSession::createPrivateBrowsingSession(base + '.' + String::number(sessionID)));
    5657}
    5758
    … …  
    6364        WKSetHTTPCookieAcceptPolicy(cookieStorage.get(), policy);
    6465
    65     for (const auto& session : SessionTracker::getSessionMap().values()) {
     66    for (const auto& session : SessionTracker::sessionMap().values()) {
    6667        if (session)
    6768            WKSetHTTPCookieAcceptPolicy(session->cookieStorage().get(), policy);
    … …  
    100101    ASSERT(isMainThread());
    101102
    102     if (frame() && frame()->settings().privateBrowsingEnabled())
    103         return *SessionTracker::session(SessionTracker::legacyPrivateSessionID);
    104 
     103    if (frame())
     104        return *SessionTracker::session(webFrameLoaderClient()->webFrame()->page()->sessionID());
    105105    return NetworkStorageSession::defaultStorageSession();
    106106}
     107
    107108WebFrameLoaderClient* WebFrameNetworkingContext::webFrameLoaderClient() const
    108109{

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp

    r162271 r162568  
    4545        return;
    4646
    47     SessionTracker::session(sessionID) = NetworkStorageSession::createPrivateBrowsingSession(String::number(sessionID));
     47    SessionTracker::setSession(sessionID, NetworkStorageSession::createPrivateBrowsingSession(String::number(sessionID)));
    4848}
    4949

  • trunk/Source/WebKit2/WebProcess/WebPage/WebFrame.cpp

    r160208 r162568  
    235235#if ENABLE(NETWORK_PROCESS)
    236236    if (WebProcess::shared().usesNetworkProcess()) {
    237         bool privateBrowsingEnabled = m_coreFrame->loader().networkingContext()->storageSession().isPrivateBrowsingSession();
    238         WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::StartDownload(privateBrowsingEnabled, policyDownloadID, request), 0);
     237        WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::StartDownload(page()->sessionID(), policyDownloadID, request), 0);
    239238        return;
    240239    }

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r162548 r162568  
    224224WebPage::WebPage(uint64_t pageID, const WebPageCreationParameters& parameters)
    225225    : m_pageID(pageID)
     226    , m_sessionID(0)
    226227    , m_viewSize(parameters.viewSize)
    227228    , m_hasSeenPlugin(false)
    … …  
    21222123}
    21232124
     2125uint64_t WebPage::sessionID() const
     2126{
     2127    if (m_sessionID)
     2128        return m_sessionID;
     2129
     2130    return m_page->settings().privateBrowsingEnabled() ? SessionTracker::legacyPrivateSessionID : SessionTracker::defaultSessionID;
     2131}
     2132
    21242133void WebPage::didReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction, uint64_t downloadID)
    21252134{
    … …  
    24242433    settings.setXSSAuditorEnabled(store.getBoolValueForKey(WebPreferencesKey::xssAuditorEnabledKey()));
    24252434    settings.setFrameFlatteningEnabled(store.getBoolValueForKey(WebPreferencesKey::frameFlatteningEnabledKey()));
    2426     settings.setPrivateBrowsingEnabled(store.getBoolValueForKey(WebPreferencesKey::privateBrowsingEnabledKey()));
     2435    if (m_sessionID)
     2436        settings.setPrivateBrowsingEnabled(SessionTracker::isEphemeralID(m_sessionID));
     2437    else
     2438        settings.setPrivateBrowsingEnabled(store.getBoolValueForKey(WebPreferencesKey::privateBrowsingEnabledKey()));
    24272439    settings.setDeveloperExtrasEnabled(store.getBoolValueForKey(WebPreferencesKey::developerExtrasEnabledKey()));
    24282440    settings.setJavaScriptExperimentsEnabled(store.getBoolValueForKey(WebPreferencesKey::javaScriptExperimentsEnabledKey()));

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

    r162548 r162568  
    180180    WebCore::Page* corePage() const { return m_page.get(); }
    181181    uint64_t pageID() const { return m_pageID; }
     182    uint64_t sessionID() const;
     183    void setSessionID(uint64_t sessionID) { m_sessionID = sessionID; }
    182184
    183185    void setSize(const WebCore::IntSize&);
    … …  
    874876
    875877    uint64_t m_pageID;
     878    uint64_t m_sessionID;
    876879
    877880    OwnPtr<WebCore::Page> m_page;

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

    r162103 r162568  
    2525    SetViewState(unsigned viewState, bool wantsDidUpdateViewState)
    2626    SetLayerHostingMode(unsigned layerHostingMode)
     27
     28    SetSessionID(uint64_t sessionID)
    2729
    2830    SetDrawsBackground(bool drawsBackground)
Note: See TracChangeset for help on using the changeset viewer.