Changeset 161890 in webkit


Ignore:
Timestamp:
Jan 13, 2014 10:25:43 AM (10 years ago)
Author:
Carlos Garcia Campos
Message:

[SOUP] Add SoupNetworkSession class to wrap a SoupSession
​https://bugs.webkit.org/show_bug.cgi?id=126813

Reviewed by Gustavo Noronha Silva.

Source/WebCore:

Add SoupNetworkSession class that wraps a SoupSession and move all
the code related to the SoupSession from ResourceHandle to
SoupNetworkSession, including the static methods to get the
default session and create testing and private sessions.

  • GNUmakefile.list.am: Add new files to compilation.
  • PlatformEfl.cmake: Ditto.
  • PlatformGTK.cmake: Ditto.
  • platform/network/NetworkStorageSession.h: Use SoupNetworkSession

instead of SoupSession.

  • platform/network/ResourceHandle.h:
  • platform/network/soup/CookieJarSoup.cpp:

(WebCore::cookieJarForSession): Use SoupNetworkSession to get the
SoupSession.

  • platform/network/soup/DNSSoup.cpp:

(WebCore::DNSResolveQueue::platformResolve): Ditto.

  • platform/network/soup/NetworkStorageSessionSoup.cpp:

(WebCore::NetworkStorageSession::NetworkStorageSession): Use
SoupNetworkSession instead of SoupSession.
(WebCore::NetworkStorageSession::~NetworkStorageSession):
(WebCore::NetworkStorageSession::defaultStorageSession): Create a
NetworkStorageSession with a NULL SoupNetworkSession which means
that the default SoupNetworkSession will be used.
(WebCore::NetworkStorageSession::createPrivateBrowsingSession):
Call SoupNetworkSession::createPrivateBrowsingSession() to create
the private session.
(WebCore::NetworkStorageSession::switchToNewTestingSession): Call
SoupNetworkSession::createTestingSession() to create the testing
session.
(WebCore::NetworkStorageSession::soupNetworkSession): Return the
SoupNetworkSession or the default one.
(WebCore::NetworkStorageSession::setSoupNetworkSession): Set a new
SoupNetworkSession.

  • platform/network/soup/ResourceHandleSoup.cpp:

(WebCore::sessionFromContext): Use SoupNetworkSession to get the
SoupSession.
(WebCore::ResourceHandleInternal::soupSession): Simply call
sessionFromContext(), since ensureSessionIsInitialized() is no
longer needed, because the SoupSession are now initialized in the
SoupNetworkSession constructor.
(WebCore::ResourceHandle::didStartRequest): Function to notify the
ResourceHandle that current request has just started for web timing.

  • platform/network/soup/SoupNetworkSession.cpp: Added.

(WebCore::soupLogPrinter): Logger callback.
(WebCore::SoupNetworkSession::defaultSession): Return a reference
to the default SoupNetworkSession.
(WebCore::SoupNetworkSession::createPrivateBrowsingSession):
Create a new private session.
(WebCore::SoupNetworkSession::createTestingSession): Create a new
testing session.
(WebCore::SoupNetworkSession::createForSoupSession): Create a new
SoupNetworkSession for the given SoupSession.
(WebCore::authenticateCallback): Callback emitted by the
SoupSession when the request needs authentication.
(WebCore::requestStartedCallback): Callback emitted by the
SoupSession when as request has just started.
(WebCore::SoupNetworkSession::SoupNetworkSession):
(WebCore::SoupNetworkSession::~SoupNetworkSession):
(WebCore::SoupNetworkSession::setupLogger): Helper private
function to setup the logger.
(WebCore::SoupNetworkSession::setCookieJar): Set a new CookieJar
in the session replacing the existing one.
(WebCore::SoupNetworkSession::cookieJar): Return the current
CookieJar of the session.
(WebCore::SoupNetworkSession::setCache): Set a disk cache.
(WebCore::SoupNetworkSession::cache): Return the current disk cache.
(WebCore::SoupNetworkSession::setSSLPolicy): Set the SSL policy.
(WebCore::SoupNetworkSession::sslPolicy): Get the current SSL policy.
(WebCore::SoupNetworkSession::setHTTPProxy): Set the HTTP proxy.
(WebCore::SoupNetworkSession::httpProxy): Get the current HTTP proxy.
(WebCore::SoupNetworkSession::setupHTTPProxyFromEnvironment): Set
the HTTP proxy using the environment variables.
(WebCore::buildAcceptLanguages): Helper function build the accept
language string in the format expected by soup (RFC 2616).
(WebCore::SoupNetworkSession::setAcceptLanguages): Set the accept
language for the given list of languages.

  • platform/network/soup/SoupNetworkSession.h: Added.

(WebCore::SoupNetworkSession::soupSession): Return the SoupSession.

Source/WebKit/efl:

Use the new SoupNetworkSession API.

  • ewk/ewk_cookies.cpp:

(ewk_cookies_file_set):

  • ewk/ewk_main.cpp:

(_ewk_init_body):

  • ewk/ewk_network.cpp:

(ewk_network_proxy_uri_set):
(ewk_network_proxy_uri_get):
(ewk_network_tls_certificate_check_get):
(ewk_network_tls_certificate_check_set):
(ewk_network_tls_ca_certificates_path_get):
(ewk_network_tls_ca_certificates_path_set):
(ewk_network_default_soup_session_get):

  • ewk/ewk_view.cpp:

(ewk_view_soup_session_get):
(ewk_view_soup_session_set):

Source/WebKit/gtk:

  • webkit/webkitglobals.cpp:

(webkit_get_default_session): Use the new SoupNetworkSession API
to get the default SoupSession

Source/WebKit2:

Use the new SoupNetworkSession API.

  • NetworkProcess/soup/NetworkProcessSoup.cpp:

(WebKit::NetworkProcess::platformInitializeNetworkProcess):
(WebKit::NetworkProcess::platformSetCacheModel):
(WebKit::NetworkProcess::clearCacheForAllOrigins):

  • NetworkProcess/unix/NetworkProcessMainUnix.cpp:

(WebKit::NetworkProcessMain):

  • WebProcess/Cookies/soup/WebCookieManagerSoup.cpp:

(WebKit::WebCookieManager::setCookiePersistentStorage):

  • WebProcess/efl/WebProcessMainEfl.cpp:

(WebKit::WebProcessMainEfl):

  • WebProcess/gtk/WebProcessMainGtk.cpp:

(WebKit::WebProcessMainGtk):

  • WebProcess/soup/WebProcessSoup.cpp:

(WebKit::WebProcess::platformSetCacheModel):
(WebKit::WebProcess::platformClearResourceCaches):
(WebKit::setSoupSessionAcceptLanguage):
(WebKit::WebProcess::platformInitializeWebProcess):

  • WebProcess/soup/WebSoupRequestManager.cpp:

(WebKit::WebSoupRequestManager::registerURIScheme):

Location:
trunk/Source
Files:
2 added
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r161889 r161890  
     12014-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [SOUP] Add SoupNetworkSession class to wrap a SoupSession
     4        https://bugs.webkit.org/show_bug.cgi?id=126813
     5
     6        Reviewed by Gustavo Noronha Silva.
     7
     8        Add SoupNetworkSession class that wraps a SoupSession and move all
     9        the code related to the SoupSession from ResourceHandle to
     10        SoupNetworkSession, including the static methods to get the
     11        default session and create testing and private sessions.
     12
     13        * GNUmakefile.list.am: Add new files to compilation.
     14        * PlatformEfl.cmake: Ditto.
     15        * PlatformGTK.cmake: Ditto.
     16        * platform/network/NetworkStorageSession.h: Use SoupNetworkSession
     17        instead of SoupSession.
     18        * platform/network/ResourceHandle.h:
     19        * platform/network/soup/CookieJarSoup.cpp:
     20        (WebCore::cookieJarForSession): Use SoupNetworkSession to get the
     21        SoupSession.
     22        * platform/network/soup/DNSSoup.cpp:
     23        (WebCore::DNSResolveQueue::platformResolve): Ditto.
     24        * platform/network/soup/NetworkStorageSessionSoup.cpp:
     25        (WebCore::NetworkStorageSession::NetworkStorageSession): Use
     26        SoupNetworkSession instead of SoupSession.
     27        (WebCore::NetworkStorageSession::~NetworkStorageSession):
     28        (WebCore::NetworkStorageSession::defaultStorageSession): Create a
     29        NetworkStorageSession with a NULL SoupNetworkSession which means
     30        that the default SoupNetworkSession will be used.
     31        (WebCore::NetworkStorageSession::createPrivateBrowsingSession):
     32        Call SoupNetworkSession::createPrivateBrowsingSession() to create
     33        the private session.
     34        (WebCore::NetworkStorageSession::switchToNewTestingSession): Call
     35        SoupNetworkSession::createTestingSession() to create the testing
     36        session.
     37        (WebCore::NetworkStorageSession::soupNetworkSession): Return the
     38        SoupNetworkSession or the default one.
     39        (WebCore::NetworkStorageSession::setSoupNetworkSession): Set a new
     40        SoupNetworkSession.
     41        * platform/network/soup/ResourceHandleSoup.cpp:
     42        (WebCore::sessionFromContext): Use SoupNetworkSession to get the
     43        SoupSession.
     44        (WebCore::ResourceHandleInternal::soupSession): Simply call
     45        sessionFromContext(), since ensureSessionIsInitialized() is no
     46        longer needed, because the SoupSession are now initialized in the
     47        SoupNetworkSession constructor.
     48        (WebCore::ResourceHandle::didStartRequest): Function to notify the
     49        ResourceHandle that current request has just started for web timing.
     50        * platform/network/soup/SoupNetworkSession.cpp: Added.
     51        (WebCore::soupLogPrinter): Logger callback.
     52        (WebCore::SoupNetworkSession::defaultSession): Return a reference
     53        to the default SoupNetworkSession.
     54        (WebCore::SoupNetworkSession::createPrivateBrowsingSession):
     55        Create a new private session.
     56        (WebCore::SoupNetworkSession::createTestingSession): Create a new
     57        testing session.
     58        (WebCore::SoupNetworkSession::createForSoupSession): Create a new
     59        SoupNetworkSession for the given SoupSession.
     60        (WebCore::authenticateCallback): Callback emitted by the
     61        SoupSession when the request needs authentication.
     62        (WebCore::requestStartedCallback): Callback emitted by the
     63        SoupSession when as request has just started.
     64        (WebCore::SoupNetworkSession::SoupNetworkSession):
     65        (WebCore::SoupNetworkSession::~SoupNetworkSession):
     66        (WebCore::SoupNetworkSession::setupLogger): Helper private
     67        function to setup the logger.
     68        (WebCore::SoupNetworkSession::setCookieJar): Set a new CookieJar
     69        in the session replacing the existing one.
     70        (WebCore::SoupNetworkSession::cookieJar): Return the current
     71        CookieJar of the session.
     72        (WebCore::SoupNetworkSession::setCache): Set a disk cache.
     73        (WebCore::SoupNetworkSession::cache): Return the current disk cache.
     74        (WebCore::SoupNetworkSession::setSSLPolicy): Set the SSL policy.
     75        (WebCore::SoupNetworkSession::sslPolicy): Get the current SSL policy.
     76        (WebCore::SoupNetworkSession::setHTTPProxy): Set the HTTP proxy.
     77        (WebCore::SoupNetworkSession::httpProxy): Get the current HTTP proxy.
     78        (WebCore::SoupNetworkSession::setupHTTPProxyFromEnvironment): Set
     79        the HTTP proxy using the environment variables.
     80        (WebCore::buildAcceptLanguages): Helper function build the accept
     81        language string in the format expected by soup (RFC 2616).
     82        (WebCore::SoupNetworkSession::setAcceptLanguages): Set the accept
     83        language for the given list of languages.
     84        * platform/network/soup/SoupNetworkSession.h: Added.
     85        (WebCore::SoupNetworkSession::soupSession): Return the SoupSession.
     86
    1872014-01-13  Brent Fulgham  <bfulgham@apple.com>
    288

  • trunk/Source/WebCore/GNUmakefile.list.am

    r161817 r161890  
    54735473        Source/WebCore/platform/network/BlobResourceHandle.cpp \
    54745474        Source/WebCore/platform/network/BlobResourceHandle.h \
    5475         Source/WebCore/platform/network/soup/CertificateInfo.h \
    54765475        Source/WebCore/platform/network/BlobStorageData.h \
    54775476        Source/WebCore/platform/network/FormDataBuilder.cpp \
    … …  
    54955494        Source/WebCore/platform/network/soup/AuthenticationChallenge.h \
    54965495        Source/WebCore/platform/network/soup/AuthenticationChallengeSoup.cpp \
     5496        Source/WebCore/platform/network/soup/CertificateInfo.h \
    54975497        Source/WebCore/platform/network/soup/CertificateInfo.cpp \
    54985498        Source/WebCore/platform/network/soup/CookieJarSoup.cpp \
    … …  
    55075507        Source/WebCore/platform/network/soup/ResourceResponse.h \
    55085508        Source/WebCore/platform/network/soup/ResourceResponseSoup.cpp \
     5509        Source/WebCore/platform/network/soup/SoupNetworkSession.h \
     5510        Source/WebCore/platform/network/soup/SoupNetworkSession.cpp \
    55095511        Source/WebCore/platform/network/soup/SynchronousLoaderClientSoup.cpp \
    55105512        Source/WebCore/platform/ScrollableArea.cpp \

  • trunk/Source/WebCore/PlatformEfl.cmake

    r161389 r161890  
    167167    platform/network/soup/ResourceResponseSoup.cpp
    168168    platform/network/soup/SocketStreamHandleSoup.cpp
     169    platform/network/soup/SoupNetworkSession.cpp
    169170    platform/network/soup/SoupURIUtils.cpp
    170171    platform/network/soup/SynchronousLoaderClientSoup.cpp

  • trunk/Source/WebCore/PlatformGTK.cmake

    r161817 r161890  
    125125    platform/network/soup/ResourceResponseSoup.cpp
    126126    platform/network/soup/SocketStreamHandleSoup.cpp
     127    platform/network/soup/SoupNetworkSession.cpp
    127128    platform/network/soup/SoupURIUtils.cpp
    128129    platform/network/soup/SynchronousLoaderClientSoup.cpp

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

    r157337 r161890  
    3333typedef const struct __CFURLStorageSession* CFURLStorageSessionRef;
    3434typedef struct OpaqueCFHTTPCookieStorage*  CFHTTPCookieStorageRef;
    35 #elif USE(SOUP)
    36 #include <wtf/gobject/GRefPtr.h>
    37 typedef struct _SoupCookieJar SoupCookieJar;
    38 typedef struct _SoupSession SoupSession;
    3935#endif
    4036
    … …  
    4238
    4339class NetworkingContext;
     40class SoupNetworkSession;
    4441
    4542class NetworkStorageSession {
    … …  
    6158    RetainPtr<CFHTTPCookieStorageRef> cookieStorage() const;
    6259#elif USE(SOUP)
    63     NetworkStorageSession(SoupSession*);
    64     void setSoupSession(SoupSession* session) { m_session = session; }
    65     SoupSession* soupSession() const { return m_session.get(); }
     60    NetworkStorageSession(std::unique_ptr<SoupNetworkSession>);
     61    ~NetworkStorageSession();
     62    SoupNetworkSession& soupNetworkSession() const;
     63    void setSoupNetworkSession(std::unique_ptr<SoupNetworkSession>);
    6664#else
    6765    NetworkStorageSession(NetworkingContext*);
    … …  
    7573    RetainPtr<CFURLStorageSessionRef> m_platformSession;
    7674#elif USE(SOUP)
    77     GRefPtr<SoupSession> m_session;
     75    std::unique_ptr<SoupNetworkSession> m_session;
    7876#else
    7977    RefPtr<NetworkingContext> m_context;

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

    r161796 r161890  
    181181    void ensureReadBuffer();
    182182    size_t currentStreamPosition() const;
    183     static SoupSession* defaultSession();
    184     static SoupSession* createTestingSession();
    185     static SoupSession* createPrivateBrowsingSession();
     183    void didStartRequest();
    186184    static uint64_t getSoupRequestInitiatingPageID(SoupRequest*);
    187185    static void setHostAllowsAnyHTTPSCertificate(const String&);

  • trunk/Source/WebCore/platform/network/soup/CookieJarSoup.cpp

    r156550 r161890  
    2727#include "NetworkingContext.h"
    2828#include "PlatformCookieJar.h"
    29 #include "ResourceHandle.h"
     29#include "SoupNetworkSession.h"
    3030#include <wtf/gobject/GRefPtr.h>
    3131#include <wtf/text/CString.h>
    … …  
    3535static SoupCookieJar* cookieJarForSession(const NetworkStorageSession& session)
    3636{
    37     ASSERT(session.soupSession());
    38     return SOUP_COOKIE_JAR(soup_session_get_feature(session.soupSession(), SOUP_TYPE_COOKIE_JAR));
     37    return session.soupNetworkSession().cookieJar();
    3938}
    4039

  • trunk/Source/WebCore/platform/network/soup/DNSSoup.cpp

    r138413 r161890  
    3030
    3131#include "GOwnPtrSoup.h"
    32 #include "ResourceHandle.h"
     32#include "SoupNetworkSession.h"
    3333#include <libsoup/soup.h>
    3434#include <wtf/MainThread.h>
    … …  
    5454    ASSERT(isMainThread());
    5555
    56     soup_session_prefetch_dns(ResourceHandle::defaultSession(), hostname.utf8().data(), 0, resolvedCallback, 0);
     56    soup_session_prefetch_dns(SoupNetworkSession::defaultSession().soupSession(), hostname.utf8().data(), nullptr, resolvedCallback, nullptr);
    5757}
    5858

  • trunk/Source/WebCore/platform/network/soup/NetworkStorageSessionSoup.cpp

    r157347 r161890  
    2929
    3030#include "ResourceHandle.h"
     31#include "SoupNetworkSession.h"
    3132#include <wtf/MainThread.h>
    3233#include <wtf/NeverDestroyed.h>
    … …  
    3435namespace WebCore {
    3536
    36 NetworkStorageSession::NetworkStorageSession(SoupSession* session)
    37     : m_session(adoptGRef(session))
     37NetworkStorageSession::NetworkStorageSession(std::unique_ptr<SoupNetworkSession> session)
     38    : m_session(std::move(session))
    3839    , m_isPrivate(false)
     40{
     41}
     42
     43NetworkStorageSession::~NetworkStorageSession()
    3944{
    4045}
    … …  
    5055{
    5156    if (!defaultSession())
    52         defaultSession() = std::make_unique<NetworkStorageSession>(ResourceHandle::defaultSession());
     57        defaultSession() = std::make_unique<NetworkStorageSession>(nullptr);
    5358    return *defaultSession();
    5459}
    … …  
    5661std::unique_ptr<NetworkStorageSession> NetworkStorageSession::createPrivateBrowsingSession(const String&)
    5762{
    58     auto session = std::make_unique<NetworkStorageSession>(ResourceHandle::createPrivateBrowsingSession());
     63    auto session = std::make_unique<NetworkStorageSession>(SoupNetworkSession::createPrivateBrowsingSession());
    5964    session->m_isPrivate = true;
    6065    return session;
    … …  
    6368void NetworkStorageSession::switchToNewTestingSession()
    6469{
    65     defaultSession() = std::make_unique<NetworkStorageSession>(ResourceHandle::createTestingSession());
     70    defaultSession() = std::make_unique<NetworkStorageSession>(SoupNetworkSession::createTestingSession());
     71}
     72
     73SoupNetworkSession& NetworkStorageSession::soupNetworkSession() const
     74{
     75    return m_session ? *m_session : SoupNetworkSession::defaultSession();
     76}
     77
     78void NetworkStorageSession::setSoupNetworkSession(std::unique_ptr<SoupNetworkSession> session)
     79{
     80    m_session = std::move(session);
    6681}
    6782

  • trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp

    r161549 r161890  
    3636#include "HTTPParsers.h"
    3737#include "LocalizedStrings.h"
    38 #include "Logging.h"
    3938#include "MIMETypeRegistry.h"
    4039#include "NetworkingContext.h"
    … …  
    4544#include "ResourceResponse.h"
    4645#include "SharedBuffer.h"
     46#include "SoupNetworkSession.h"
    4747#include "SoupURIUtils.h"
    4848#include "TextEncoding.h"
    … …  
    7373namespace WebCore {
    7474
    75 inline static void soupLogPrinter(SoupLogger*, SoupLoggerLogLevel, char direction, const char* data, gpointer)
    76 {
    77 #if LOG_DISABLED
    78     UNUSED_PARAM(direction);
    79     UNUSED_PARAM(data);
    80 #endif
    81     LOG(Network, "%c %s", direction, data);
    82 }
    83 
    8475static bool loadingSynchronousRequest = false;
    8576static const size_t gDefaultReadBufferSize = 8192;
    … …  
    261252{
    262253    if (!context || !context->isValid())
    263         return ResourceHandle::defaultSession();
    264     return context->storageSession().soupSession();
     254        return SoupNetworkSession::defaultSession().soupSession();
     255    return context->storageSession().soupNetworkSession().soupSession();
    265256}
    266257
    … …  
    270261}
    271262
    272 static void ensureSessionIsInitialized(SoupSession* session)
    273 {
    274     if (g_object_get_data(G_OBJECT(session), "webkit-init"))
    275         return;
    276 
    277     if (session == ResourceHandle::defaultSession()) {
    278         SoupCookieJar* jar = SOUP_COOKIE_JAR(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR));
    279         if (!jar)
    280             soup_session_add_feature(session, SOUP_SESSION_FEATURE(soupCookieJar()));
    281         else
    282             setSoupCookieJar(jar);
    283     }
    284 
    285 #if !LOG_DISABLED
    286     if (!soup_session_get_feature(session, SOUP_TYPE_LOGGER) && LogNetwork.state == WTFLogChannelOn) {
    287         SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(SOUP_LOGGER_LOG_BODY), -1);
    288         soup_session_add_feature(session, SOUP_SESSION_FEATURE(logger));
    289         soup_logger_set_printer(logger, soupLogPrinter, 0, 0);
    290         g_object_unref(logger);
    291     }
    292 #endif // !LOG_DISABLED
    293 
    294     g_object_set_data(G_OBJECT(session), "webkit-init", reinterpret_cast<void*>(0xdeadbeef));
    295 }
    296 
    297263SoupSession* ResourceHandleInternal::soupSession()
    298264{
    299     SoupSession* session = sessionFromContext(m_context.get());
    300     ensureSessionIsInitialized(session);
    301     return session;
     265    return sessionFromContext(m_context.get());
    302266}
    303267
    … …  
    880844}
    881845
    882 static void requestStartedCallback(SoupSession*, SoupMessage* soupMessage, SoupSocket*, gpointer)
    883 {
    884     RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(g_object_get_data(G_OBJECT(soupMessage), "handle"));
    885     if (!handle)
    886         return;
    887 
    888     ResourceHandleInternal* d = handle->getInternal();
     846void ResourceHandle::didStartRequest()
     847{
     848    ResourceHandleInternal* d = getInternal();
    889849    if (!d->m_response.resourceLoadTiming())
    890850        return;
    … …  
    14321392}
    14331393
    1434 static void authenticateCallback(SoupSession* session, SoupMessage* soupMessage, SoupAuth* soupAuth, gboolean retrying)
    1435 {
    1436     RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(g_object_get_data(G_OBJECT(soupMessage), "handle"));
    1437     if (!handle)
    1438         return;
    1439     handle->didReceiveAuthenticationChallenge(AuthenticationChallenge(session, soupMessage, soupAuth, retrying, handle.get()));
    1440 }
    1441 
    1442 static SoupSession* createSoupSession()
    1443 {
    1444     // Values taken from http://www.browserscope.org/  following
    1445     // the rule "Do What Every Other Modern Browser Is Doing". They seem
    1446     // to significantly improve page loading time compared to soup's
    1447     // default values.
    1448     static const int maxConnections = 35;
    1449     static const int maxConnectionsPerHost = 6;
    1450 
    1451     SoupSession* session = soup_session_async_new();
    1452     g_object_set(session,
    1453         SOUP_SESSION_MAX_CONNS, maxConnections,
    1454         SOUP_SESSION_MAX_CONNS_PER_HOST, maxConnectionsPerHost,
    1455         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
    1456         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_SNIFFER,
    1457         SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
    1458         SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
    1459         NULL);
    1460     g_signal_connect(session, "authenticate", G_CALLBACK(authenticateCallback), 0);
    1461 
    1462 #if ENABLE(WEB_TIMING)
    1463     g_signal_connect(session, "request-started", G_CALLBACK(requestStartedCallback), 0);
    1464 #endif
    1465 
    1466     return session;
    1467 }
    1468 
    1469 SoupSession* ResourceHandle::defaultSession()
    1470 {
    1471     static SoupSession* session = createSoupSession();
    1472     return session;
    1473 }
    1474 
    1475 SoupSession* ResourceHandle::createTestingSession()
    1476 {
    1477     SoupSession* session = createSoupSession();
    1478     // The testing session operates with the default cookie jar.
    1479     soup_session_add_feature(session, SOUP_SESSION_FEATURE(soupCookieJar()));
    1480     return session;
    1481 }
    1482 
    1483 SoupSession* ResourceHandle::createPrivateBrowsingSession()
    1484 {
    1485     SoupSession* session = createSoupSession();
    1486     soup_session_add_feature(session, SOUP_SESSION_FEATURE(createPrivateBrowsingCookieJar()));
    1487     return session;
    1488 }
    1489 
    14901394uint64_t ResourceHandle::getSoupRequestInitiatingPageID(SoupRequest* request)
    14911395{

  • trunk/Source/WebKit/efl/ChangeLog

    r161860 r161890  
     12014-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [SOUP] Add SoupNetworkSession class to wrap a SoupSession
     4        https://bugs.webkit.org/show_bug.cgi?id=126813
     5
     6        Reviewed by Gustavo Noronha Silva.
     7
     8        Use the new SoupNetworkSession API.
     9
     10        * ewk/ewk_cookies.cpp:
     11        (ewk_cookies_file_set):
     12        * ewk/ewk_main.cpp:
     13        (_ewk_init_body):
     14        * ewk/ewk_network.cpp:
     15        (ewk_network_proxy_uri_set):
     16        (ewk_network_proxy_uri_get):
     17        (ewk_network_tls_certificate_check_get):
     18        (ewk_network_tls_certificate_check_set):
     19        (ewk_network_tls_ca_certificates_path_get):
     20        (ewk_network_tls_ca_certificates_path_set):
     21        (ewk_network_default_soup_session_get):
     22        * ewk/ewk_view.cpp:
     23        (ewk_view_soup_session_get):
     24        (ewk_view_soup_session_set):
     25
    1262014-01-12  Jinwoo Song  <jinwoo7.song@samsung.com>
    227

  • trunk/Source/WebKit/efl/ewk/ewk_cookies.cpp

    r123604 r161890  
    2323
    2424#include "CookieJarSoup.h"
    25 #include "ResourceHandle.h"
     25#include "SoupNetworkSession.h"
    2626#include <Eina.h>
    2727#include <eina_safety_checks.h>
    … …  
    4343    soup_cookie_jar_set_accept_policy(cookieJar, SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
    4444
    45     SoupSession* session = WebCore::ResourceHandle::defaultSession();
    46     SoupSessionFeature* oldjar = soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR);
    47     if (oldjar)
    48         soup_session_remove_feature(session, oldjar);
    49 
     45    WebCore::SoupNetworkSession::defaultSession().setCookieJar(cookieJar);
    5046    WebCore::setSoupCookieJar(cookieJar);
    51     soup_session_add_feature(session, SOUP_SESSION_FEATURE(cookieJar));
     47    g_object_unref(cookieJar);
    5248
    5349    return true;

  • trunk/Source/WebKit/efl/ewk/ewk_main.cpp

    r159486 r161890  
    3030#include "ScriptController.h"
    3131#include "Settings.h"
     32#include "SoupNetworkSession.h"
    3233#include "StorageTracker.h"
    3334#include "StorageTrackerClientEfl.h"
    … …  
    205206    WebCore::StorageTracker::initializeTracker(localStorageDirectory.utf8().data(), trackerClient());
    206207
    207     SoupSession* session = WebCore::ResourceHandle::defaultSession();
    208208    SoupSessionFeature* auth_dialog = static_cast<SoupSessionFeature*>(g_object_new(EWK_TYPE_SOUP_AUTH_DIALOG, 0));
    209     soup_session_add_feature(session, auth_dialog);
     209    soup_session_add_feature(WebCore::SoupNetworkSession::defaultSession().soupSession(), auth_dialog);
    210210
    211211    WebCore::ResourceHandle::setIgnoreSSLErrors(true);

  • trunk/Source/WebKit/efl/ewk/ewk_network.cpp

    r148511 r161890  
    2424#include "ProxyResolverSoup.h"
    2525#include "ResourceHandle.h"
     26#include "SoupNetworkSession.h"
    2627#include "ewk_private.h"
    2728#include <Eina.h>
    … …  
    3132void ewk_network_proxy_uri_set(const char* proxy)
    3233{
    33     SoupSession* session = WebCore::ResourceHandle::defaultSession();
    34 
    35     if (!proxy) {
     34    if (!proxy)
    3635        ERR("no proxy uri. remove proxy feature in soup.");
    37         soup_session_remove_feature_by_type(session, SOUP_TYPE_PROXY_URI_RESOLVER);
    38         return;
    39     }
    40 
    41     SoupProxyURIResolver* resolverEfl = soupProxyResolverWkNew(proxy, 0);
    42     soup_session_add_feature(session, SOUP_SESSION_FEATURE(resolverEfl));
    43     g_object_unref(resolverEfl);
     36    WebCore::SoupNetworkSession::defaultSession().setHTTPProxy(proxy, 0);
    4437}
    4538
    4639const char* ewk_network_proxy_uri_get(void)
    4740{
    48     SoupURI* uri;
    49     SoupSession* session = WebCore::ResourceHandle::defaultSession();
    50     SoupProxyURIResolver* resolver = SOUP_PROXY_URI_RESOLVER(soup_session_get_feature(session, SOUP_TYPE_PROXY_URI_RESOLVER));
    51     if (!resolver)
    52         return 0;
    53 
    54     g_object_get(resolver, SOUP_PROXY_RESOLVER_WK_PROXY_URI, &uri, NULL);
    55 
     41    char* uri = WebCore::SoupNetworkSession::defaultSession().httpProxy();
    5642    if (!uri) {
    5743        ERR("no proxy uri");
    … …  
    5945    }
    6046
    61     WTF::String proxy = soup_uri_to_string(uri, false);
    62     return eina_stringshare_add(proxy.utf8().data());
     47    return eina_stringshare_add(uri);
    6348}
    6449
    6550Eina_Bool ewk_network_tls_certificate_check_get()
    6651{
    67     bool checkCertificates = false;
    68 
    69     SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession();
    70     g_object_get(defaultSession, "ssl-strict", &checkCertificates, NULL);
    71 
    72     return checkCertificates;
     52    unsigned policy = WebCore::SoupNetworkSession::defaultSession().sslPolicy();
     53    return policy & WebCore::SoupNetworkSession::SSLStrict;
    7354}
    7455
    7556void ewk_network_tls_certificate_check_set(Eina_Bool checkCertificates)
    7657{
    77     SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession();
    78     g_object_set(defaultSession, "ssl-strict", checkCertificates, NULL);
     58    unsigned policy = WebCore::SoupNetworkSession::defaultSession().sslPolicy();
     59    WebCore::SoupNetworkSession::defaultSession().setSSLPolicy(policy | WebCore::SoupNetworkSession::SSLStrict);
    7960}
    8061
    … …  
    8364    const char* bundlePath = 0;
    8465
    85     SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession();
     66    SoupSession* defaultSession = WebCore::SoupNetworkSession::defaultSession().soupSession();
    8667    g_object_get(defaultSession, "ssl-ca-file", &bundlePath, NULL);
    8768
    … …  
    9172void ewk_network_tls_ca_certificates_path_set(const char* bundlePath)
    9273{
    93     SoupSession* defaultSession = WebCore::ResourceHandle::defaultSession();
     74    SoupSession* defaultSession = WebCore::SoupNetworkSession::defaultSession().soupSession();
    9475    g_object_set(defaultSession, "ssl-ca-file", bundlePath, NULL);
    9576}
    … …  
    9778SoupSession* ewk_network_default_soup_session_get()
    9879{
    99     return WebCore::ResourceHandle::defaultSession();
     80    return WebCore::SoupNetworkSession::defaultSession().soupSession();
    10081}

  • trunk/Source/WebKit/efl/ewk/ewk_view.cpp

    r161744 r161890  
    6666#include "ScriptController.h"
    6767#include "Settings.h"
     68#include "SoupNetworkSession.h"
    6869#include "TiledBackingStore.h"
    6970#include "c_instance.h"
    … …  
    45474548    EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, 0);
    45484549    EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, 0);
    4549     return priv->storageSession->soupSession();
     4550    return priv->storageSession->soupNetworkSession().soupSession();
    45504551}
    45514552
    … …  
    45594560        return;
    45604561    }
    4561     priv->storageSession->setSoupSession(session);
     4562    priv->storageSession->setSoupNetworkSession(WebCore::SoupNetworkSession::createForSoupSession(session));
    45624563}
    45634564

  • trunk/Source/WebKit/gtk/ChangeLog

    r161870 r161890  
     12014-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [SOUP] Add SoupNetworkSession class to wrap a SoupSession
     4        https://bugs.webkit.org/show_bug.cgi?id=126813
     5
     6        Reviewed by Gustavo Noronha Silva.
     7
     8        * webkit/webkitglobals.cpp:
     9        (webkit_get_default_session): Use the new SoupNetworkSession API
     10        to get the default SoupSession
     11
    1122014-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
    213

  • trunk/Source/WebKit/gtk/webkit/webkitglobals.cpp

    r155714 r161890  
    4040#include "ResourceResponse.h"
    4141#include "SchemeRegistry.h"
     42#include "SoupNetworkSession.h"
    4243#include "TextEncodingRegistry.h"
    4344#include "webkitapplicationcache.h"
    … …  
    8485{
    8586    webkitInit();
    86     return ResourceHandle::defaultSession();
     87    return SoupNetworkSession::defaultSession().soupSession();
    8788}
    8889

  • trunk/Source/WebKit2/ChangeLog

    r161882 r161890  
     12014-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [SOUP] Add SoupNetworkSession class to wrap a SoupSession
     4        https://bugs.webkit.org/show_bug.cgi?id=126813
     5
     6        Reviewed by Gustavo Noronha Silva.
     7
     8        Use the new SoupNetworkSession API.
     9
     10        * NetworkProcess/soup/NetworkProcessSoup.cpp:
     11        (WebKit::NetworkProcess::platformInitializeNetworkProcess):
     12        (WebKit::NetworkProcess::platformSetCacheModel):
     13        (WebKit::NetworkProcess::clearCacheForAllOrigins):
     14        * NetworkProcess/unix/NetworkProcessMainUnix.cpp:
     15        (WebKit::NetworkProcessMain):
     16        * WebProcess/Cookies/soup/WebCookieManagerSoup.cpp:
     17        (WebKit::WebCookieManager::setCookiePersistentStorage):
     18        * WebProcess/efl/WebProcessMainEfl.cpp:
     19        (WebKit::WebProcessMainEfl):
     20        * WebProcess/gtk/WebProcessMainGtk.cpp:
     21        (WebKit::WebProcessMainGtk):
     22        * WebProcess/soup/WebProcessSoup.cpp:
     23        (WebKit::WebProcess::platformSetCacheModel):
     24        (WebKit::WebProcess::platformClearResourceCaches):
     25        (WebKit::setSoupSessionAcceptLanguage):
     26        (WebKit::WebProcess::platformInitializeWebProcess):
     27        * WebProcess/soup/WebSoupRequestManager.cpp:
     28        (WebKit::WebSoupRequestManager::registerURIScheme):
     29
    1302014-01-13  Zalan Bujtas  <zalan@apple.com>
    231

  • trunk/Source/WebKit2/NetworkProcess/soup/NetworkProcessSoup.cpp

    r161112 r161890  
    3636#include <WebCore/NotImplemented.h>
    3737#include <WebCore/ResourceHandle.h>
     38#include <WebCore/SoupNetworkSession.h>
    3839#include <libsoup/soup.h>
    3940#include <wtf/gobject/GOwnPtr.h>
    … …  
    7980    ASSERT(!parameters.diskCacheDirectory.isEmpty());
    8081    GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(parameters.diskCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER));
    81     soup_session_add_feature(WebCore::ResourceHandle::defaultSession(), SOUP_SESSION_FEATURE(soupCache.get()));
     82    SoupNetworkSession::defaultSession().setCache(soupCache.get());
    8283    soup_cache_load(soupCache.get());
    8384
    … …  
    102103    unsigned long urlCacheDiskCapacity = 0;
    103104
    104     SoupSession* session = ResourceHandle::defaultSession();
    105     SoupCache* cache = SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE));
     105    SoupCache* cache = SoupNetworkSession::defaultSession().cache();
    106106    uint64_t diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024;
    107107
    … …  
    130130        return;
    131131
    132     SoupSession* session = ResourceHandle::defaultSession();
    133     soup_cache_clear(SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE)));
     132    soup_cache_clear(SoupNetworkSession::defaultSession().cache());
    134133}
    135134

  • trunk/Source/WebKit2/NetworkProcess/unix/NetworkProcessMainUnix.cpp

    r161816 r161890  
    3232#include "WKBase.h"
    3333#include "WebKit2Initialize.h"
    34 #include <WebCore/ResourceHandle.h>
     34#include <WebCore/SoupNetworkSession.h>
    3535#include <WebKit2/NetworkProcess.h>
    3636#include <error.h>
    … …  
    4242
    4343#if PLATFORM(EFL)
    44 #include "ProxyResolverSoup.h"
    4544#include <Ecore.h>
    4645#endif
    … …  
    6968    InitializeWebKit2();
    7069
    71 #if USE(SOUP)
    72     SoupSession* session = ResourceHandle::defaultSession();
    73 #if PLATFORM(EFL)
    74     // Only for EFL because GTK port uses the default resolver, which uses GIO's proxy resolver.
    75     const char* httpProxy = getenv("http_proxy");
    76     if (httpProxy) {
    77         const char* noProxy = getenv("no_proxy");
    78         GRefPtr<SoupProxyURIResolver> resolver = adoptGRef(soupProxyResolverWkNew(httpProxy, noProxy));
    79         soup_session_add_feature(session, SOUP_SESSION_FEATURE(resolver.get()));
    80     }
    81 #endif
    82 #endif
     70    SoupNetworkSession::defaultSession().setupHTTPProxyFromEnvironment();
    8371
    8472    int socket = atoi(argv[1]);
    … …  
    9381    // accepting invalid certificates by default. New API will be
    9482    // added later to let client accept/discard invalid certificates.
    95     g_object_set(session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
    96         SOUP_SESSION_SSL_STRICT, FALSE, NULL);
     83    SoupNetworkSession::defaultSession().setSSLPolicy(SoupNetworkSession::SSLUseSystemCAFile);
    9784#endif
    9885
    … …  
    10087
    10188#if USE(SOUP)
    102     if (SoupSessionFeature* soupCache = soup_session_get_feature(session, SOUP_TYPE_CACHE)) {
    103         soup_cache_flush(SOUP_CACHE(soupCache));
    104         soup_cache_dump(SOUP_CACHE(soupCache));
     89    if (SoupCache* soupCache = SoupNetworkSession::defaultSession().cache()) {
     90        soup_cache_flush(soupCache);
     91        soup_cache_dump(soupCache);
    10592    }
    10693#endif

  • trunk/Source/WebKit2/WebProcess/Cookies/soup/WebCookieManagerSoup.cpp

    r139261 r161890  
    3030#include "WebKitSoupCookieJarSqlite.h"
    3131#include <WebCore/CookieJarSoup.h>
    32 #include <WebCore/ResourceHandle.h>
     32#include <WebCore/SoupNetworkSession.h>
    3333#include <libsoup/soup.h>
    3434#include <wtf/gobject/GRefPtr.h>
    … …  
    9797    }
    9898
    99     SoupCookieJar* currentJar = WebCore::soupCookieJar();
    100     soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(currentJar));
    101     SoupSession* session = ResourceHandle::defaultSession();
    102     soup_session_remove_feature(session, SOUP_SESSION_FEATURE(currentJar));
    103     soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar.get()));
    104 
     99    soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(WebCore::soupCookieJar()));
     100    SoupNetworkSession::defaultSession().setCookieJar(jar.get());
    105101    WebCore::setSoupCookieJar(jar.get());
    106102}

  • trunk/Source/WebKit2/WebProcess/efl/WebProcessMainEfl.cpp

    r159001 r161890  
    3636#include <WebCore/AuthenticationChallenge.h>
    3737#include <WebCore/NetworkingContext.h>
    38 #include <WebCore/ResourceHandle.h>
     38#include <WebCore/SoupNetworkSession.h>
    3939#include <WebKit2/WebProcess.h>
    4040#include <libsoup/soup.h>
    … …  
    115115    InitializeWebKit2();
    116116
    117     SoupSession* session = WebCore::ResourceHandle::defaultSession();
    118     const char* httpProxy = getenv("http_proxy");
    119     if (httpProxy) {
    120         const char* noProxy = getenv("no_proxy");
    121         SoupProxyURIResolver* resolverEfl = soupProxyResolverWkNew(httpProxy, noProxy);
    122         soup_session_add_feature(session, SOUP_SESSION_FEATURE(resolverEfl));
    123         g_object_unref(resolverEfl);
    124     }
     117    SoupNetworkSession::defaultSession().setupHTTPProxyFromEnvironment();
    125118
    126119    int socket = atoi(argv[1]);
    … …  
    133126    RunLoop::run();
    134127
    135     if (SoupSessionFeature* soupCache = soup_session_get_feature(session, SOUP_TYPE_CACHE)) {
    136         soup_cache_flush(SOUP_CACHE(soupCache));
    137         soup_cache_dump(SOUP_CACHE(soupCache));
     128    if (SoupCache* soupCache = SoupNetworkSession::defaultSession().cache()) {
     129        soup_cache_flush(soupCache);
     130        soup_cache_dump(soupCache);
    138131    }
    139132

  • trunk/Source/WebKit2/WebProcess/gtk/WebProcessMainGtk.cpp

    r159001 r161890  
    3232#include <WebCore/AuthenticationChallenge.h>
    3333#include <WebCore/NetworkingContext.h>
    34 #include <WebCore/ResourceHandle.h>
     34#include <WebCore/SoupNetworkSession.h>
    3535#include <WebKit2/WebProcess.h>
    3636#include <gtk/gtk.h>
    … …  
    7272    // accepting invalid certificates by default. New API will be
    7373    // added later to let client accept/discard invalid certificates.
    74     SoupSession* session = WebCore::ResourceHandle::defaultSession();
    75     g_object_set(session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
    76                  SOUP_SESSION_SSL_STRICT, FALSE, NULL);
     74    SoupNetworkSession::defaultSession().setSSLPolicy(SoupNetworkSession::SSLUseSystemCAFile);
    7775
    7876    RunLoop::run();
    7977
    80     if (SoupSessionFeature* soupCache = soup_session_get_feature(session, SOUP_TYPE_CACHE)) {
    81         soup_cache_flush(SOUP_CACHE(soupCache));
    82         soup_cache_dump(SOUP_CACHE(soupCache));
     78    if (SoupCache* soupCache = SoupNetworkSession::defaultSession().cache()) {
     79        soup_cache_flush(soupCache);
     80        soup_cache_dump(soupCache);
    8381    }
    8482

  • trunk/Source/WebKit2/WebProcess/soup/WebProcessSoup.cpp

    r161272 r161890  
    4141#include <WebCore/PageCache.h>
    4242#include <WebCore/ResourceHandle.h>
     43#include <WebCore/SoupNetworkSession.h>
    4344#include <libsoup/soup.h>
    4445#include <wtf/gobject/GOwnPtr.h>
    4546#include <wtf/gobject/GRefPtr.h>
    46 #include <wtf/text/CString.h>
    47 #include <wtf/text/StringBuilder.h>
    4847
    4948namespace WebKit {
    … …  
    9594
    9695    if (!usesNetworkProcess()) {
    97         cache = SOUP_CACHE(soup_session_get_feature(WebCore::ResourceHandle::defaultSession(), SOUP_TYPE_CACHE));
     96        cache = WebCore::SoupNetworkSession::defaultSession().cache();
    9897        diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024;
    9998    }
    … …  
    123122        return;
    124123
    125     soup_cache_clear(SOUP_CACHE(soup_session_get_feature(WebCore::ResourceHandle::defaultSession(), SOUP_TYPE_CACHE)));
    126 }
    127 
    128 // This function is based on Epiphany code in ephy-embed-prefs.c.
    129 static CString buildAcceptLanguages(Vector<String> languages)
    130 {
    131     // Ignore "C" locale.
    132     size_t position = languages.find("c");
    133     if (position != notFound)
    134         languages.remove(position);
    135 
    136     // Fallback to "en" if the list is empty.
    137     if (languages.isEmpty())
    138         return "en";
    139 
    140     // Calculate deltas for the quality values.
    141     int delta;
    142     if (languages.size() < 10)
    143         delta = 10;
    144     else if (languages.size() < 20)
    145         delta = 5;
    146     else
    147         delta = 1;
    148 
    149     // Set quality values for each language.
    150     StringBuilder builder;
    151     for (size_t i = 0; i < languages.size(); ++i) {
    152         if (i)
    153             builder.append(", ");
    154 
    155         builder.append(languages[i]);
    156 
    157         int quality = 100 - i * delta;
    158         if (quality > 0 && quality < 100) {
    159             char buffer[8];
    160             g_ascii_formatd(buffer, 8, "%.2f", quality / 100.0);
    161             builder.append(String::format(";q=%s", buffer));
    162         }
    163     }
    164 
    165     return builder.toString().utf8();
     124    soup_cache_clear(WebCore::SoupNetworkSession::defaultSession().cache());
    166125}
    167126
    168127static void setSoupSessionAcceptLanguage(Vector<String> languages)
    169128{
    170     g_object_set(WebCore::ResourceHandle::defaultSession(), "accept-language", buildAcceptLanguages(languages).data(), NULL);
     129    WebCore::SoupNetworkSession::defaultSession().setAcceptLanguages(languages);
    171130}
    172131
    … …  
    192151    ASSERT(!parameters.diskCacheDirectory.isEmpty());
    193152    GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(parameters.diskCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER));
    194     soup_session_add_feature(WebCore::ResourceHandle::defaultSession(), SOUP_SESSION_FEATURE(soupCache.get()));
     153    WebCore::SoupNetworkSession::defaultSession().setCache(soupCache.get());
    195154    soup_cache_load(soupCache.get());
    196155

  • trunk/Source/WebKit2/WebProcess/soup/WebSoupRequestManager.cpp

    r161156 r161890  
    3131#include <WebCore/ResourceHandle.h>
    3232#include <WebCore/ResourceRequest.h>
     33#include <WebCore/SoupNetworkSession.h>
    3334#include <wtf/gobject/GOwnPtr.h>
    3435#include <wtf/text/CString.h>
    … …  
    99100    g_ptr_array_add(m_schemes.get(), 0);
    100101
    101     SoupSession* session = WebCore::ResourceHandle::defaultSession();
     102    SoupSession* session = WebCore::SoupNetworkSession::defaultSession().soupSession();
    102103    SoupRequestClass* genericRequestClass = static_cast<SoupRequestClass*>(g_type_class_ref(WEBKIT_TYPE_SOUP_REQUEST_GENERIC));
    103104    genericRequestClass->schemes = const_cast<const char**>(reinterpret_cast<char**>(m_schemes->pdata));
Note: See TracChangeset for help on using the changeset viewer.