Changeset 61500 in webkit


Ignore:
Timestamp:
Jun 19, 2010 5:39:44 PM (14 years ago)
Author:
weinig@apple.com
Message:

Fix for ​https://bugs.webkit.org/show_bug.cgi?id=40882
Add ability to have a WebProcess per WebContext.

Reviewed by Anders Carlsson.

WebKit2:

  • Move to a one-to-one correspondence of WebContexts to WebProcessProxies.
  • Add explicit shared contexts for general use.
  • Only non-shared contexts can use injected bundles.
  • UIProcess/API/C/WKContext.cpp:

(WKContextCreate):
(WKContextCreateWithInjectedBundlePath):
(WKContextGetSharedProcessContext):
(WKContextGetSharedThreadContext):

  • UIProcess/API/C/WKContext.h:
  • UIProcess/API/C/WKContextPrivate.h:

Change API for WKContext to no longer take a WKProcessModel type and instead
have explicit Create/Get functions for the different kind of contexts. Added
two shared contexts, one threaded, one process, and made the threaded on private
for now.

  • UIProcess/API/mac/WKView.mm:

(-[WKView initWithFrame:]):
Make WKViews that don't have an explicit context use the shared process
context by default.

  • UIProcess/Launcher/WebProcessLauncher.h:
  • UIProcess/Launcher/mac/WebProcessLauncher.mm:

(WebKit::launchWebProcess):

  • UIProcess/Launcher/win/WebProcessLauncher.cpp:

(WebKit::launchWebProcess):
Use a boolean argument to note whether we are using a thread or a process
instead of using the process model enum.

  • UIProcess/ProcessModel.h:

(WebKit::):
Convert to using explicit Shared modifier for shared contexts.

  • UIProcess/WebContext.cpp:

(WebKit::WebContext::sharedProcessContext):
(WebKit::WebContext::sharedThreadContext):
(WebKit::WebContext::ensureWebProcess):
(WebKit::WebContext::createWebPage):
(WebKit::WebContext::reviveIfNecessary):

  • UIProcess/WebContext.h:

(WebKit::WebContext::create):
(WebKit::WebContext::process):

  • UIProcess/WebPageNamespace.cpp:

(WebKit::WebPageNamespace::createWebPage):
(WebKit::WebPageNamespace::preferencesDidChange):
(WebKit::WebPageNamespace::getStatistics):

  • UIProcess/WebPageNamespace.h:

(WebKit::WebPageNamespace::process):
(WebKit::WebPageNamespace::reviveIfNecessary):
Move WebProcessProxy creation logic up into WebContext.

  • UIProcess/WebProcessManager.cpp:

(WebKit::WebProcessManager::getWebProcess):
(WebKit::WebProcessManager::processDidClose):

  • UIProcess/WebProcessManager.h:

Keep a map of WebContexts to WebProcessProxies in addition to the two
shared processes.

  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::create):
(WebKit::WebProcessProxy::WebProcessProxy):
(WebKit::WebProcessProxy::connect):
(WebKit::WebProcessProxy::didClose):

  • UIProcess/WebProcessProxy.h:

Store a WebContext instead of the process model.

  • mac/WebKit2.exp:

Add new functions.

WebKitTools:

Move to use new shared contexts API.

  • MiniBrowser/mac/AppDelegate.h:
  • MiniBrowser/mac/AppDelegate.m:

(-[BrowserAppDelegate init]):
(-[BrowserAppDelegate getCurrentPageNamespace]):
(-[BrowserAppDelegate validateMenuItem:]):
(-[BrowserAppDelegate _setProcessModel:]):
(-[BrowserAppDelegate setSharedProcessProcessModel:]):
(-[BrowserAppDelegate setSharedThreadProcessModel:]):

  • MiniBrowser/win/BrowserView.cpp:

(BrowserView::create):

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebKit2/ChangeLog

    r61453 r61500  
     12010-06-19  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Anders Carlsson.
     4
     5        Fix for https://bugs.webkit.org/show_bug.cgi?id=40882
     6        Add ability to have a WebProcess per WebContext.
     7
     8        - Move to a one-to-one correspondence of WebContexts to WebProcessProxies.
     9        - Add explicit shared contexts for general use.
     10        - Only non-shared contexts can use injected bundles.
     11
     12        * UIProcess/API/C/WKContext.cpp:
     13        (WKContextCreate):
     14        (WKContextCreateWithInjectedBundlePath):
     15        (WKContextGetSharedProcessContext):
     16        (WKContextGetSharedThreadContext):
     17        * UIProcess/API/C/WKContext.h:
     18        * UIProcess/API/C/WKContextPrivate.h:
     19        Change API for WKContext to no longer take a WKProcessModel type and instead
     20        have explicit Create/Get functions for the different kind of contexts. Added
     21        two shared contexts, one threaded, one process, and made the threaded on private
     22        for now.
     23
     24        * UIProcess/API/mac/WKView.mm:
     25        (-[WKView initWithFrame:]):
     26        Make WKViews that don't have an explicit context use the shared process
     27        context by default.
     28
     29        * UIProcess/Launcher/WebProcessLauncher.h:
     30        * UIProcess/Launcher/mac/WebProcessLauncher.mm:
     31        (WebKit::launchWebProcess):
     32        * UIProcess/Launcher/win/WebProcessLauncher.cpp:
     33        (WebKit::launchWebProcess):
     34        Use a boolean argument to note whether we are using a thread or a process
     35        instead of using the process model enum.
     36
     37        * UIProcess/ProcessModel.h:
     38        (WebKit::):
     39        Convert to using explicit Shared modifier for shared contexts.
     40
     41        * UIProcess/WebContext.cpp:
     42        (WebKit::WebContext::sharedProcessContext):
     43        (WebKit::WebContext::sharedThreadContext):
     44        (WebKit::WebContext::ensureWebProcess):
     45        (WebKit::WebContext::createWebPage):
     46        (WebKit::WebContext::reviveIfNecessary):
     47        * UIProcess/WebContext.h:
     48        (WebKit::WebContext::create):
     49        (WebKit::WebContext::process):
     50        * UIProcess/WebPageNamespace.cpp:
     51        (WebKit::WebPageNamespace::createWebPage):
     52        (WebKit::WebPageNamespace::preferencesDidChange):
     53        (WebKit::WebPageNamespace::getStatistics):
     54        * UIProcess/WebPageNamespace.h:
     55        (WebKit::WebPageNamespace::process):
     56        (WebKit::WebPageNamespace::reviveIfNecessary):
     57        Move WebProcessProxy creation logic up into WebContext.
     58
     59        * UIProcess/WebProcessManager.cpp:
     60        (WebKit::WebProcessManager::getWebProcess):
     61        (WebKit::WebProcessManager::processDidClose):
     62        * UIProcess/WebProcessManager.h:
     63        Keep a map of WebContexts to WebProcessProxies in addition to the two
     64        shared processes.
     65
     66        * UIProcess/WebProcessProxy.cpp:
     67        (WebKit::WebProcessProxy::create):
     68        (WebKit::WebProcessProxy::WebProcessProxy):
     69        (WebKit::WebProcessProxy::connect):
     70        (WebKit::WebProcessProxy::didClose):
     71        * UIProcess/WebProcessProxy.h:
     72        Store a WebContext instead of the process model.
     73
     74        * mac/WebKit2.exp:
     75        Add new functions.
     76
    1772010-06-18  Anders Carlsson  <andersca@apple.com>
    278

  • trunk/WebKit2/UIProcess/API/C/WKContext.cpp

    r61222 r61500  
    2727#include "WKContextPrivate.h"
    2828
    29 #include "ProcessModel.h"
    3029#include "WKAPICast.h"
    3130#include "WebContext.h"
    … …  
    3736using namespace WebKit;
    3837
    39 static ProcessModel toWK(WKProcessModel wkProcessModel)
     38WKContextRef WKContextCreate()
    4039{
    41     switch (wkProcessModel) {
    42         case kWKProcessModelSecondaryProcess:
    43             return ProcessModelSecondaryProcess;
    44         case kWKProcessModelSecondaryThread:
    45             return ProcessModelSecondaryThread;
    46         default:
    47             ASSERT_NOT_REACHED();
    48     }
    49 
    50     // Default to SecondaryProcess if a bad value is passed.
    51     return ProcessModelSecondaryProcess;
    52 }
    53 
    54 WKContextRef WKContextCreate(WKProcessModel wkProcessModel)
    55 {
    56     RefPtr<WebContext> context = WebContext::create(toWK(wkProcessModel), WebCore::String());
     40    RefPtr<WebContext> context = WebContext::create(WebCore::String());
    5741    return toRef(context.release().releaseRef());
    5842}
    5943
    60 WKContextRef WKContextCreateWithInjectedBundlePath(WKProcessModel wkProcessModel, WKStringRef pathRef)
     44WKContextRef WKContextCreateWithInjectedBundlePath(WKStringRef pathRef)
    6145{
    62     RefPtr<WebContext> context = WebContext::create(toWK(wkProcessModel), toWK(pathRef));
     46    RefPtr<WebContext> context = WebContext::create(toWK(pathRef));
    6347    return toRef(context.release().releaseRef());
     48}
     49
     50WKContextRef WKContextGetSharedProcessContext()
     51{
     52    return toRef(WebContext::sharedProcessContext());
     53}
     54
     55WKContextRef WKContextGetSharedThreadContext()
     56{
     57    return toRef(WebContext::sharedThreadContext());
    6458}
    6559

  • trunk/WebKit2/UIProcess/API/C/WKContext.h

    r61222 r61500  
    3333#endif
    3434
    35 enum {
    36     kWKProcessModelSecondaryProcess = 0,
    37     kWKProcessModelSecondaryThread = 1
    38 };
    39 typedef unsigned long WKProcessModel;
     35WK_EXPORT WKContextRef WKContextCreate();
     36WK_EXPORT WKContextRef WKContextCreateWithInjectedBundlePath(WKStringRef path);
    4037
    41 WK_EXPORT WKContextRef WKContextCreate(WKProcessModel processModel);
    42 WK_EXPORT WKContextRef WKContextCreateWithInjectedBundlePath(WKProcessModel processModel, WKStringRef path);
     38WK_EXPORT WKContextRef WKContextGetSharedProcessContext();
    4339
    4440WK_EXPORT void WKContextSetPreferences(WKContextRef context, WKPreferencesRef preferences);

  • trunk/WebKit2/UIProcess/API/C/WKContextPrivate.h

    r58117 r61500  
    4343WK_EXPORT void WKContextGetStatistics(WKContextRef context, WKContextStatistics* statistics);
    4444
     45WK_EXPORT WKContextRef WKContextGetSharedThreadContext();
     46
    4547#ifdef __cplusplus
    4648}

  • trunk/WebKit2/UIProcess/API/mac/WKView.mm

    r61228 r61500  
    8989- (id)initWithFrame:(NSRect)frame
    9090{
    91     RefPtr<WebContext> context = WebContext::create(ProcessModelSecondaryProcess, String());
     91    WebContext* context = WebContext::sharedProcessContext();
    9292    self = [self initWithFrame:frame pageNamespaceRef:toRef(context->createPageNamespace())];
    9393    if (!self)

  • trunk/WebKit2/UIProcess/Launcher/WebProcessLauncher.h

    r57310 r61500  
    2929#include "Connection.h"
    3030#include "PlatformProcessIdentifier.h"
    31 #include "ProcessModel.h"
    3231#include <wtf/RefPtr.h>
    3332
    … …  
    3938};
    4039
    41 ProcessInfo launchWebProcess(CoreIPC::Connection::Client*, ProcessModel);
     40ProcessInfo launchWebProcess(CoreIPC::Connection::Client*, bool useThread);
    4241
    4342} // namespace WebKit

  • trunk/WebKit2/UIProcess/Launcher/mac/WebProcessLauncher.mm

    r58266 r61500  
    6060}
    6161
    62 ProcessInfo launchWebProcess(CoreIPC::Connection::Client* client, ProcessModel processModel)
     62ProcessInfo launchWebProcess(CoreIPC::Connection::Client* client, bool useThread)
    6363{
    6464    ProcessInfo info = { 0, 0 };
    … …  
    7474    info.connection->open();
    7575
    76     switch (processModel) {
    77         case ProcessModelSecondaryThread: {
    78             // Pass it to the thread.
    79             if (!createThread(webThreadBody, reinterpret_cast<void*>(listeningPort), "WebKit2: WebThread")) {
    80                 // FIXME: Destroy ports.
    81                 return info;
    82             }
    83             }
    84             break;
    85         case ProcessModelSecondaryProcess: {
    86             NSString *webProcessAppPath = [[NSBundle bundleWithIdentifier:@"com.apple.WebKit2"] pathForAuxiliaryExecutable:@"WebProcess.app"];
    87             NSString *webProcessAppExecutablePath = [[NSBundle bundleWithPath:webProcessAppPath] executablePath];
     76    if (useThread) {
     77        // Pass it to the thread.
     78        if (!createThread(webThreadBody, reinterpret_cast<void*>(listeningPort), "WebKit2: WebThread")) {
     79            // FIXME: Destroy ports.
     80            return info;
     81        }
     82    } else {
     83        NSString *webProcessAppPath = [[NSBundle bundleWithIdentifier:@"com.apple.WebKit2"] pathForAuxiliaryExecutable:@"WebProcess.app"];
     84        NSString *webProcessAppExecutablePath = [[NSBundle bundleWithPath:webProcessAppPath] executablePath];
    8885
    89             const char* path = [webProcessAppExecutablePath fileSystemRepresentation];
    90             const char* args[] = { path, 0 };
     86        const char* path = [webProcessAppExecutablePath fileSystemRepresentation];
     87        const char* args[] = { path, 0 };
    9188
    92             // Register ourselves.
    93             kern_return_t kr = bootstrap_register2(bootstrap_port, (char*)"com.apple.WebKit.WebProcess", listeningPort, /* BOOTSTRAP_PER_PID_SERVICE */ 1);
    94             if (kr)
    95                 NSLog(@"bootstrap_register2 result: %x", kr);
    96            
    97             int result = posix_spawn(&info.processIdentifier, path, 0, 0, (char *const*)args, *_NSGetEnviron());
    98             if (result)
    99                 NSLog(@"posix_spawn result: %d", result);
    100         }
    101         break;
     89        // Register ourselves.
     90        kern_return_t kr = bootstrap_register2(bootstrap_port, (char*)"com.apple.WebKit.WebProcess", listeningPort, /* BOOTSTRAP_PER_PID_SERVICE */ 1);
     91        if (kr)
     92            NSLog(@"bootstrap_register2 result: %x", kr);
     93       
     94        int result = posix_spawn(&info.processIdentifier, path, 0, 0, (char *const*)args, *_NSGetEnviron());
     95        if (result)
     96            NSLog(@"posix_spawn result: %d", result);
    10297    }
    10398

  • trunk/WebKit2/UIProcess/Launcher/win/WebProcessLauncher.cpp

    r61155 r61500  
    5454}
    5555
    56 ProcessInfo launchWebProcess(CoreIPC::Connection::Client* client, ProcessModel model)
     56ProcessInfo launchWebProcess(CoreIPC::Connection::Client* client, bool useThread)
    5757{
    5858    ProcessInfo info = { 0, 0 };
    … …  
    6161    info.connection->open();
    6262
    63     switch (model) {
    64         case ProcessModelSecondaryThread: {
    65             // FIXME: Pass the handle.
    66             if (createThread(webThreadBody, 0, "WebKit2: WebThread")) {
    67                 info.processIdentifier = ::GetCurrentProcess();
    68                 return info;
    69             }
    70             break;
     63    if (useThread) {
     64        // FIXME: Pass the handle.
     65        if (createThread(webThreadBody, 0, "WebKit2: WebThread")) {
     66            info.processIdentifier = ::GetCurrentProcess();
     67            return info;
    7168        }
    72         case ProcessModelSecondaryProcess: {
    73             // FIXME: We would like to pass a full path to the .exe here.
     69    } else {
     70        // FIXME: We would like to pass a full path to the .exe here.
    7471#ifndef DEBUG_ALL
    75             String commandLine(L"WebKit2WebProcess.exe");
     72        String commandLine(L"WebKit2WebProcess.exe");
    7673#else
    77             String commandLine(L"WebKit2WebProcess_debug.exe");
     74        String commandLine(L"WebKit2WebProcess_debug.exe");
    7875#endif
    7976
    80             STARTUPINFO startupInfo = { 0 };
    81             startupInfo.cb = sizeof(startupInfo);
    82             PROCESS_INFORMATION processInformation = { 0 };
    83             BOOL result = ::CreateProcessW(0, (LPWSTR)commandLine.charactersWithNullTermination(),
    84                                            0, 0, false, 0, 0, 0, &startupInfo, &processInformation);
    85             if (!result) {
    86                 // FIXME: What should we do here?
    87                 DWORD error = ::GetLastError();
    88                 ASSERT_NOT_REACHED();
    89             }
     77        STARTUPINFO startupInfo = { 0 };
     78        startupInfo.cb = sizeof(startupInfo);
     79        PROCESS_INFORMATION processInformation = { 0 };
     80        BOOL result = ::CreateProcessW(0, (LPWSTR)commandLine.charactersWithNullTermination(),
     81                                       0, 0, false, 0, 0, 0, &startupInfo, &processInformation);
     82        if (!result) {
     83            // FIXME: What should we do here?
     84            DWORD error = ::GetLastError();
     85            ASSERT_NOT_REACHED();
     86        }
    9087
    91             // Don't leak the thread handle.
    92             ::CloseHandle(processInformation.hThread);
     88        // Don't leak the thread handle.
     89        ::CloseHandle(processInformation.hThread);
    9390
    94             info.processIdentifier = processInformation.hProcess;
    95         }
     91        info.processIdentifier = processInformation.hProcess;
    9692    }
    9793

  • trunk/WebKit2/UIProcess/ProcessModel.h

    r57310 r61500  
    3030
    3131enum ProcessModel {
    32     ProcessModelSecondaryProcess,
    33     ProcessModelSecondaryThread
     32    ProcessModelSharedSecondaryProcess,
     33    ProcessModelSharedSecondaryThread,
     34    ProcessModelSecondaryProcess
    3435};
    3536

  • trunk/WebKit2/UIProcess/WebContext.cpp

    r61222 r61500  
    3030#include "WebPreferences.h"
    3131#include "WebProcessManager.h"
     32#include "WebProcessProxy.h"
    3233
    3334#include "WKContextPrivate.h"
    … …  
    4445static WTF::RefCountedLeakCounter webContextCounter("WebContext");
    4546#endif
     47
     48WebContext* WebContext::sharedProcessContext()
     49{
     50    static WebContext* context = new WebContext(ProcessModelSharedSecondaryProcess, String());
     51    return context;
     52}
     53
     54WebContext* WebContext::sharedThreadContext()
     55{
     56    static WebContext* context = new WebContext(ProcessModelSharedSecondaryThread, String());
     57    return context;
     58}
    4659
    4760WebContext::WebContext(ProcessModel processModel, const WebCore::String& injectedBundlePath)
    … …  
    6780    webContextCounter.decrement();
    6881#endif
     82}
     83
     84void WebContext::ensureWebProcess()
     85{
     86    if (m_process && m_process->isValid())
     87        return;
     88
     89    m_process = WebProcessManager::shared().getWebProcess(this);
     90}
     91
     92WebPageProxy* WebContext::createWebPage(WebPageNamespace* pageNamespace)
     93{
     94    ensureWebProcess();
     95    return m_process->createWebPage(pageNamespace);
     96}
     97
     98void WebContext::reviveIfNecessary()
     99{
     100    ensureWebProcess();
    69101}
    70102

  • trunk/WebKit2/UIProcess/WebContext.h

    r61222 r61500  
    2929#include "ProcessModel.h"
    3030#include <WebCore/PlatformString.h>
     31#include <wtf/Forward.h>
    3132#include <wtf/HashSet.h>
    3233#include <wtf/PassRefPtr.h>
    … …  
    3940
    4041class WebPageNamespace;
     42class WebPageProxy;
    4143class WebPreferences;
     44class WebProcessProxy;
    4245
    4346class WebContext : public RefCounted<WebContext> {
    4447public:
    45     static PassRefPtr<WebContext> create(ProcessModel processModel, const WebCore::String& injectedBundlePath)
     48    static WebContext* sharedProcessContext();
     49    static WebContext* sharedThreadContext();
     50
     51    static PassRefPtr<WebContext> create(const WebCore::String& injectedBundlePath)
    4652    {
    47         return adoptRef(new WebContext(processModel, injectedBundlePath));
     53        return adoptRef(new WebContext(ProcessModelSecondaryProcess, injectedBundlePath));
    4854    }
     55
    4956    ~WebContext();
    5057
    5158    ProcessModel processModel() const { return m_processModel; }
     59    WebProcessProxy* process() const { return m_process.get(); }
     60
     61    WebPageProxy* createWebPage(WebPageNamespace*);
     62
     63    void reviveIfNecessary();
    5264
    5365    WebPageNamespace* createPageNamespace();
    … …  
    6577    WebContext(ProcessModel, const WebCore::String& injectedBundlePath);
    6678
     79    void ensureWebProcess();
     80
    6781    ProcessModel m_processModel;
     82   
     83    // FIXME: In the future, this should be one or more WebProcessProxies.
     84    RefPtr<WebProcessProxy> m_process;
     85
    6886    HashSet<WebPageNamespace*> m_pageNamespaces;
    6987    RefPtr<WebPreferences> m_preferences;

  • trunk/WebKit2/UIProcess/WebPageNamespace.cpp

    r61222 r61500  
    6161WebPageProxy* WebPageNamespace::createWebPage()
    6262{
    63     ensureWebProcess();
    64 
    65     return m_process->createWebPage(this);
    66 }
    67 
    68 void WebPageNamespace::ensureWebProcess()
    69 {
    70     if (m_process && m_process->isValid())
    71         return;
    72 
    73     m_process = WebProcessManager::shared().getWebProcess(m_context->processModel(), m_context->injectedBundlePath());
    74 }
    75 
    76 void WebPageNamespace::reviveIfNecessary()
    77 {
    78     if (m_process->isValid())
    79         return;
    80 
    81     // FIXME: The WebContext should hand us the new ProcessProxy based on its process model.
    82     m_process = WebProcessManager::shared().getWebProcess(m_context->processModel(), m_context->injectedBundlePath());
     63    return m_context->createWebPage(this);
    8364}
    8465
    8566void WebPageNamespace::preferencesDidChange()
    8667{
    87     for (WebProcessProxy::pages_const_iterator it = m_process->pages_begin(), end = m_process->pages_end(); it != end; ++it)
     68    for (WebProcessProxy::pages_const_iterator it = process()->pages_begin(), end = process()->pages_end(); it != end; ++it)
    8869        (*it)->preferencesDidChange();
    8970}
    … …  
    9172void WebPageNamespace::getStatistics(WKContextStatistics* statistics)
    9273{
    93     if (!m_process)
     74    if (!process())
    9475        return;
    9576
    96     statistics->numberOfWKPages += m_process->numberOfPages();
     77    statistics->numberOfWKPages += process()->numberOfPages();
    9778
    98     for (WebProcessProxy::pages_const_iterator it = m_process->pages_begin(), end = m_process->pages_end(); it != end; ++it)
     79    for (WebProcessProxy::pages_const_iterator it = process()->pages_begin(), end = process()->pages_end(); it != end; ++it)
    9980        (*it)->getStatistics(statistics);
    10081}

  • trunk/WebKit2/UIProcess/WebPageNamespace.h

    r58117 r61500  
    2828
    2929#include "WebContext.h"
    30 #include "WebProcessProxy.h"
    3130#include <wtf/PassRefPtr.h>
    3231#include <wtf/RefCounted.h>
    … …  
    5150
    5251    WebContext* context() const { return m_context.get(); }
    53     WebProcessProxy* process() const { return m_process.get(); }
    54 
    55     void reviveIfNecessary();
     52    WebProcessProxy* process() const { return m_context->process(); }
     53    void reviveIfNecessary() { m_context->reviveIfNecessary(); }
    5654
    5755    void preferencesDidChange();
    … …  
    6159private:
    6260    WebPageNamespace(WebContext*);
    63    
    64     void ensureWebProcess();
    65    
     61
    6662    RefPtr<WebContext> m_context;
    67     RefPtr<WebProcessProxy> m_process;
    6863};
    6964

  • trunk/WebKit2/UIProcess/WebProcessManager.cpp

    r61222 r61500  
    2626#include "WebProcessManager.h"
    2727
    28 #include <WebCore/PlatformString.h>
    29 
    30 using namespace WebCore;
     28#include "WebContext.h"
    3129
    3230namespace WebKit {
    … …  
    4240}
    4341
    44 WebProcessProxy* WebProcessManager::getWebProcess(ProcessModel processModel, const String& injectedBundlePath)
     42WebProcessProxy* WebProcessManager::getWebProcess(WebContext* context)
    4543{
    46     switch (processModel) {
    47         case ProcessModelSecondaryProcess:
     44    switch (context->processModel()) {
     45        case ProcessModelSharedSecondaryProcess: {
    4846            if (!m_sharedProcess)
    49                 m_sharedProcess = WebProcessProxy::create(processModel, injectedBundlePath);
     47                m_sharedProcess = WebProcessProxy::create(context);
    5048            return m_sharedProcess.get();
    51         case ProcessModelSecondaryThread:
     49        }
     50        case ProcessModelSharedSecondaryThread: {
    5251            if (!m_sharedThread)
    53                 m_sharedThread = WebProcessProxy::create(processModel, injectedBundlePath);
     52                m_sharedThread = WebProcessProxy::create(context);
    5453            return m_sharedThread.get();
     54        }
     55        case ProcessModelSecondaryProcess: {
     56            std::pair<ProcessMap::iterator, bool> result = m_processMap.add(context, 0);
     57            if (result.second) {
     58                ASSERT(!result.first->second);
     59                result.first->second = WebProcessProxy::create(context);
     60            }
     61
     62            ASSERT(result.first->second);
     63            return result.first->second.get();
     64        }
    5565    }
    56 
    5766   
    5867    ASSERT_NOT_REACHED();
    5968    return 0;
    6069}
    61    
    62 void WebProcessManager::processDidClose(WebProcessProxy* process)
     70
     71void WebProcessManager::processDidClose(WebProcessProxy* process, WebContext* context)
    6372{
    6473    if (process == m_sharedProcess) {
     74        ASSERT(context->processModel() == ProcessModelSharedSecondaryProcess);
    6575        m_sharedProcess = 0;
    6676        return;
    6777    }
    68    
     78
     79    ProcessMap::iterator it = m_processMap.find(context);
     80    if (it != m_processMap.end()) {
     81        ASSERT(it->second == process);
     82        m_processMap.remove(it);
     83    }
     84
    6985    // The shared thread connection should never be closed.
    7086    ASSERT_NOT_REACHED();

  • trunk/WebKit2/UIProcess/WebProcessManager.h

    r61222 r61500  
    2727#define WebProcessManager_h
    2828
    29 #include "ProcessModel.h"
    3029#include "WebProcessProxy.h"
    3130#include <wtf/HashMap.h>
    3231#include <wtf/RefPtr.h>
    3332
    34 namespace WebCore {
    35     class String;
    36 };
    37 
    3833namespace WebKit {
    39 
    40 class WebProcessProxy;
    41 class WebPageNamespace;
    4234
    4335class WebProcessManager {
    … …  
    4537    static WebProcessManager& shared();
    4638
    47     WebProcessProxy* getWebProcess(ProcessModel, const WebCore::String& injectedBundlePath);
    48 
    49     void processDidClose(WebProcessProxy*);
     39    WebProcessProxy* getWebProcess(WebContext*);
     40    void processDidClose(WebProcessProxy*, WebContext*);
    5041
    5142private:
    5243    WebProcessManager();
     44
    5345    RefPtr<WebProcessProxy> m_sharedThread;
    5446    RefPtr<WebProcessProxy> m_sharedProcess;
     47
     48    typedef HashMap<WebContext*, RefPtr<WebProcessProxy> > ProcessMap;
     49    ProcessMap m_processMap;
    5550};
    5651

  • trunk/WebKit2/UIProcess/WebProcessProxy.cpp

    r61222 r61500  
    2626#include "WebProcessProxy.h"
    2727
     28#include "WebContext.h"
    2829#include "WebPageNamespace.h"
    2930#include "WebPageProxy.h"
    … …  
    4344}
    4445
    45 PassRefPtr<WebProcessProxy> WebProcessProxy::create(ProcessModel processModel, const String& injectedBundlePath)
     46PassRefPtr<WebProcessProxy> WebProcessProxy::create(WebContext* context)
    4647{
    47     return adoptRef(new WebProcessProxy(processModel, injectedBundlePath));
     48    return adoptRef(new WebProcessProxy(context));
    4849}
    4950
    50 WebProcessProxy::WebProcessProxy(ProcessModel processModel, const String& injectedBundlePath)
     51WebProcessProxy::WebProcessProxy(WebContext* context)
    5152    : m_responsivenessTimer(this)
    52     , m_processModel(processModel)
     53    , m_context(context)
    5354{
    5455    connect();
    … …  
    5657    // FIXME: We could instead send the bundle path as part of the arguments to process creation?
    5758    // Would that be better than sending a connection?
    58     if (!injectedBundlePath.isEmpty())
    59         connection()->send(WebProcessMessage::LoadInjectedBundle, 0, CoreIPC::In(injectedBundlePath));
     59    if (!context->injectedBundlePath().isEmpty())
     60        connection()->send(WebProcessMessage::LoadInjectedBundle, 0, CoreIPC::In(context->injectedBundlePath()));
    6061}
    6162
    … …  
    6768void WebProcessProxy::connect()
    6869{
    69     ProcessInfo info = launchWebProcess(this, m_processModel);
     70    ProcessInfo info = launchWebProcess(this, m_context->processModel() == ProcessModelSharedSecondaryThread);
    7071    if (!info.connection) {
    7172        // FIXME: Report an error.
    … …  
    165166
    166167    // This may cause us to be deleted.
    167     WebProcessManager::shared().processDidClose(this);   
     168    WebProcessManager::shared().processDidClose(this, m_context);
    168169}
    169170

  • trunk/WebKit2/UIProcess/WebProcessProxy.h

    r61222 r61500  
    4242namespace WebKit {
    4343
     44class WebContext;
    4445class WebPageNamespace;
    4546
    … …  
    4950    typedef WebPageProxyMap::const_iterator::Values pages_const_iterator;
    5051
    51     static PassRefPtr<WebProcessProxy> create(ProcessModel, const WebCore::String& injectedBundlePath);
     52    static PassRefPtr<WebProcessProxy> create(WebContext*);
    5253    ~WebProcessProxy();
    5354
    … …  
    6970    bool isValid() const { return m_connection; }
    7071
    71     ProcessModel processModel() const { return m_processModel; }
    72 
    7372    PlatformProcessIdentifier processIdentifier() const { return m_platformProcessIdentifier; }
    7473
    7574private:
    76     explicit WebProcessProxy(ProcessModel, const WebCore::String& injectedBundlePath);
     75    explicit WebProcessProxy(WebContext*);
    7776
    7877    void connect();
    … …  
    9190    PlatformProcessIdentifier m_platformProcessIdentifier;
    9291
    93     ProcessModel m_processModel;
     92    WebContext* m_context;
    9493
    9594    // NOTE: This map is for pages in all WebPageNamespaces that use this process.

  • trunk/WebKit2/mac/WebKit2.exp

    r61453 r61500  
    55_WKContextCreate
    66_WKContextCreateWithInjectedBundlePath
     7_WKContextGetSharedProcessContext
     8_WKContextGetSharedThreadContext
    79_WKContextGetStatistics
    810_WKContextRelease

  • trunk/WebKit2/win/WebKit2Generated.make

    r61222 r61500  
    55    xcopy /y /d "..\UIProcess\API\C\WKBase.h" "$(WEBKITOUTPUTDIR)\include\WebKit2"
    66    xcopy /y /d "..\UIProcess\API\C\WKContext.h" "$(WEBKITOUTPUTDIR)\include\WebKit2"
     7    xcopy /y /d "..\UIProcess\API\C\WKContextPrivate.h" "$(WEBKITOUTPUTDIR)\include\WebKit2"
    78    xcopy /y /d "..\UIProcess\API\C\WKFrame.h" "$(WEBKITOUTPUTDIR)\include\WebKit2"
    89    xcopy /y /d "..\UIProcess\API\C\WKFramePolicyListener.h" "$(WEBKITOUTPUTDIR)\include\WebKit2"

  • trunk/WebKitTools/ChangeLog

    r61478 r61500  
     12010-06-19  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Anders Carlsson.
     4
     5        Fix for https://bugs.webkit.org/show_bug.cgi?id=40882
     6        Add ability to have a WebProcess per WebContext.
     7
     8        Move to use new shared contexts API.
     9
     10        * MiniBrowser/mac/AppDelegate.h:
     11        * MiniBrowser/mac/AppDelegate.m:
     12        (-[BrowserAppDelegate init]):
     13        (-[BrowserAppDelegate getCurrentPageNamespace]):
     14        (-[BrowserAppDelegate validateMenuItem:]):
     15        (-[BrowserAppDelegate _setProcessModel:]):
     16        (-[BrowserAppDelegate setSharedProcessProcessModel:]):
     17        (-[BrowserAppDelegate setSharedThreadProcessModel:]):
     18        * MiniBrowser/win/BrowserView.cpp:
     19        (BrowserView::create):
     20
    1212010-06-02  Robert Hogan  <robert@webkit.org>
    222

  • trunk/WebKitTools/MiniBrowser/mac/AppDelegate.h

    r58117 r61500  
    2424 */
    2525
     26enum ProcessModel {
     27    kProcessModelSharedSecondaryThread,
     28    kProcessModelSharedSecondaryProcess
     29};
     30typedef unsigned long ProcessModel;
     31
    2632@interface BrowserAppDelegate : NSObject <NSApplicationDelegate> {
    27     WKProcessModel currentProcessModel;
     33    ProcessModel currentProcessModel;
    2834    WKPageNamespaceRef threadPageNamespace;
    2935    WKPageNamespaceRef processPageNamespace;

  • trunk/WebKitTools/MiniBrowser/mac/AppDelegate.m

    r61222 r61500  
    3030
    3131#import <WebKit2/WKStringCF.h>
     32#import <WebKit2/WKContextPrivate.h>
    3233
    3334static NSString *defaultURL = @"http://webkit.org/";
    … …  
    4041    if (self) {
    4142        if ([NSEvent modifierFlags] & NSShiftKeyMask)
    42             currentProcessModel = kWKProcessModelSecondaryThread;
     43            currentProcessModel = kProcessModelSharedSecondaryThread;
    4344        else
    44             currentProcessModel = kWKProcessModelSecondaryProcess;
     45            currentProcessModel = kProcessModelSharedSecondaryProcess;
     46
     47        WKContextRef threadContext = WKContextGetSharedThreadContext();
     48        threadPageNamespace = WKPageNamespaceCreate(threadContext);
     49        WKContextRelease(threadContext);
    4550
    4651        CFStringRef bundlePathCF = (CFStringRef)[[NSBundle mainBundle] pathForAuxiliaryExecutable:@"WebBundle.bundle"];
    4752        WKStringRef bundlePath = WKStringCreateWithCFString(bundlePathCF);
    4853
    49         WKContextRef threadContext = WKContextCreateWithInjectedBundlePath(kWKProcessModelSecondaryThread, bundlePath);
    50         threadPageNamespace = WKPageNamespaceCreate(threadContext);
    51         WKContextRelease(threadContext);
    52 
    53         WKContextRef processContext = WKContextCreateWithInjectedBundlePath(kWKProcessModelSecondaryProcess, bundlePath);
     54        WKContextRef processContext = WKContextCreateWithInjectedBundlePath(bundlePath);
    5455        processPageNamespace = WKPageNamespaceCreate(processContext);
    5556        WKContextRelease(processContext);
    … …  
    7172- (WKPageNamespaceRef)getCurrentPageNamespace
    7273{
    73     return (currentProcessModel == kWKProcessModelSecondaryThread) ? threadPageNamespace : processPageNamespace;
     74    return (currentProcessModel == kProcessModelSharedSecondaryThread) ? threadPageNamespace : processPageNamespace;
    7475}
    7576
    … …  
    7778{
    7879    if ([menuItem action] == @selector(setSharedProcessProcessModel:))
    79         [menuItem setState:currentProcessModel == kWKProcessModelSecondaryProcess ? NSOnState : NSOffState];
     80        [menuItem setState:currentProcessModel == kProcessModelSharedSecondaryProcess ? NSOnState : NSOffState];
    8081    else if ([menuItem action] == @selector(setSharedThreadProcessModel:))
    81         [menuItem setState:currentProcessModel == kWKProcessModelSecondaryThread ? NSOnState : NSOffState];
     82        [menuItem setState:currentProcessModel == kProcessModelSharedSecondaryThread ? NSOnState : NSOffState];
    8283    return YES;
    8384}       
    8485
    85 - (void)_setProcessModel:(WKProcessModel)processModel
     86- (void)_setProcessModel:(ProcessModel)processModel
    8687{
    8788    if (processModel == currentProcessModel)
    … …  
    9394- (IBAction)setSharedProcessProcessModel:(id)sender
    9495{
    95     [self _setProcessModel:kWKProcessModelSecondaryProcess];
     96    [self _setProcessModel:kProcessModelSharedSecondaryProcess];
    9697}
    9798
    9899- (IBAction)setSharedThreadProcessModel:(id)sender
    99100{
    100     [self _setProcessModel:kWKProcessModelSecondaryThread];
     101    [self _setProcessModel:kProcessModelSharedSecondaryThread];
    101102}
    102103

  • trunk/WebKitTools/MiniBrowser/win/BrowserView.cpp

    r61222 r61500  
    2828
    2929#include "BrowserWindow.h"
     30#include <WebKit2/WKContextPrivate.h>
    3031#include <WebKit2/WKURLCF.h>
    3132
    … …  
    6768    bool isShiftKeyDown = ::GetKeyState(VK_SHIFT) & HIGH_BIT_MASK_SHORT;
    6869
    69     WKContextRef context = WKContextCreate(isShiftKeyDown ? kWKProcessModelSecondaryThread : kWKProcessModelSecondaryProcess);
     70    WKContextRef context;
     71    if (isShiftKeyDown)
     72        context = WKContextGetSharedThreadContext();
     73    else
     74        context = WKContextGetSharedProcessContext();
     75
    7076    WKPageNamespaceRef pageNamespace = WKPageNamespaceCreate(context);
    7177
Note: See TracChangeset for help on using the changeset viewer.