diff options
28 files changed, 1162 insertions, 1380 deletions
diff --git a/chrome/browser/browser_child_process_host.h b/chrome/browser/browser_child_process_host.h index 7524018..f917a4d 100644 --- a/chrome/browser/browser_child_process_host.h +++ b/chrome/browser/browser_child_process_host.h @@ -116,6 +116,10 @@ class BrowserChildProcessHost : public ChildProcessHost, // the host list. Calls ChildProcessHost::ForceShutdown virtual void ForceShutdown(); + ResourceDispatcherHost* resource_dispatcher_host() { + return resource_dispatcher_host_; + } + private: void Initialize(ResourceMessageFilter::URLRequestContextOverride* url_request_context_override); diff --git a/chrome/browser/renderer_host/browser_render_process_host.cc b/chrome/browser/renderer_host/browser_render_process_host.cc index c9e63385..c018061 100644 --- a/chrome/browser/renderer_host/browser_render_process_host.cc +++ b/chrome/browser/renderer_host/browser_render_process_host.cc @@ -16,6 +16,7 @@ #endif #include "app/app_switches.h" +#include "base/callback.h" #include "base/command_line.h" #include "base/logging.h" #include "base/metrics/field_trial.h" @@ -66,6 +67,7 @@ #include "chrome/browser/spellcheck_host.h" #include "chrome/browser/metrics/user_metrics.h" #include "chrome/browser/visitedlink/visitedlink_master.h" +#include "chrome/browser/worker_host/worker_message_filter.h" #include "chrome/common/chrome_paths.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/child_process_info.h" @@ -462,6 +464,13 @@ void BrowserRenderProcessHost::CreateMessageFilters() { socket_stream_dispatcher_host->set_url_request_context_override( url_request_context_override); channel_->AddFilter(socket_stream_dispatcher_host); + + channel_->AddFilter(new WorkerMessageFilter( + id(), + profile()->GetRequestContext(), + g_browser_process->resource_dispatcher_host(), + NewCallbackWithReturnValue( + widget_helper_.get(), &RenderWidgetHelper::GetNextRoutingID))); } int BrowserRenderProcessHost::GetNextRoutingID() { diff --git a/chrome/browser/renderer_host/render_message_filter.cc b/chrome/browser/renderer_host/render_message_filter.cc index 453e5c5..2bda4a6 100644 --- a/chrome/browser/renderer_host/render_message_filter.cc +++ b/chrome/browser/renderer_host/render_message_filter.cc @@ -44,8 +44,6 @@ #include "chrome/browser/renderer_host/render_widget_helper.h" #include "chrome/browser/spellchecker_platform_engine.h" #include "chrome/browser/task_manager/task_manager.h" -#include "chrome/browser/worker_host/message_port_dispatcher.h" -#include "chrome/browser/worker_host/worker_service.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/extensions/extension_file_util.h" #include "chrome/common/extensions/extension_message_bundle.h" @@ -245,8 +243,6 @@ RenderMessageFilter::RenderMessageFilter( profile->GetDesktopNotificationService()->prefs_cache()), host_zoom_map_(profile->GetHostZoomMap()), off_the_record_(profile->IsOffTheRecord()), - next_route_id_callback_(NewCallbackWithReturnValue( - render_widget_helper, &RenderWidgetHelper::GetNextRoutingID)), webkit_context_(profile->GetWebKitContext()), render_process_id_(render_process_id) { request_context_ = profile_->GetRequestContext(); @@ -264,183 +260,139 @@ RenderMessageFilter::RenderMessageFilter( RenderMessageFilter::~RenderMessageFilter() { // This function should be called on the IO thread. DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); - - // Let interested observers know we are being deleted. - NotificationService::current()->Notify( - NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN, - Source<RenderMessageFilter>(this), - NotificationService::NoDetails()); -} - -// Called on the IPC thread: -void RenderMessageFilter::OnChannelConnected(int32 peer_pid) { - BrowserMessageFilter::OnChannelConnected(peer_pid); - - WorkerService::GetInstance()->Initialize(resource_dispatcher_host_); -} - -void RenderMessageFilter::OnChannelError() { - BrowserMessageFilter::OnChannelError(); - - NotificationService::current()->Notify( - NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN, - Source<RenderMessageFilter>(this), - NotificationService::NoDetails()); } // Called on the IPC thread: bool RenderMessageFilter::OnMessageReceived(const IPC::Message& message, bool* message_was_ok) { - MessagePortDispatcher* mp_dispatcher = MessagePortDispatcher::GetInstance(); - bool handled = mp_dispatcher->OnMessageReceived( - message, this, next_route_id_callback(), message_was_ok); - - if (!handled) { - handled = true; - IPC_BEGIN_MESSAGE_MAP_EX(RenderMessageFilter, message, *message_was_ok) - // On Linux we need to dispatch these messages to the UI2 thread - // because we cannot make X calls from the IO thread. Mac - // doesn't have windowed plug-ins so we handle the messages in - // the UI thread. On Windows, we intercept the messages and - // handle them directly. + bool handled = true; + IPC_BEGIN_MESSAGE_MAP_EX(RenderMessageFilter, message, *message_was_ok) + // On Linux we need to dispatch these messages to the UI2 thread + // because we cannot make X calls from the IO thread. Mac + // doesn't have windowed plug-ins so we handle the messages in + // the UI thread. On Windows, we intercept the messages and + // handle them directly. #if !defined(OS_MACOSX) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetScreenInfo, - OnGetScreenInfo) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetWindowRect, - OnGetWindowRect) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetRootWindowRect, - OnGetRootWindowRect) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetScreenInfo, OnGetScreenInfo) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetWindowRect, OnGetWindowRect) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetRootWindowRect, + OnGetRootWindowRect) #endif - IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWindow, OnMsgCreateWindow) - IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWidget, OnMsgCreateWidget) - IPC_MESSAGE_HANDLER(ViewHostMsg_CreateFullscreenWidget, - OnMsgCreateFullscreenWidget) - IPC_MESSAGE_HANDLER(ViewHostMsg_SetCookie, OnSetCookie) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetCookies, OnGetCookies) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetRawCookies, - OnGetRawCookies) - IPC_MESSAGE_HANDLER(ViewHostMsg_DeleteCookie, OnDeleteCookie) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_CookiesEnabled, - OnCookiesEnabled) + IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWindow, OnMsgCreateWindow) + IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWidget, OnMsgCreateWidget) + IPC_MESSAGE_HANDLER(ViewHostMsg_CreateFullscreenWidget, + OnMsgCreateFullscreenWidget) + IPC_MESSAGE_HANDLER(ViewHostMsg_SetCookie, OnSetCookie) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetCookies, OnGetCookies) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetRawCookies, OnGetRawCookies) + IPC_MESSAGE_HANDLER(ViewHostMsg_DeleteCookie, OnDeleteCookie) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_CookiesEnabled, + OnCookiesEnabled) #if defined(OS_MACOSX) - IPC_MESSAGE_HANDLER(ViewHostMsg_LoadFont, OnLoadFont) + IPC_MESSAGE_HANDLER(ViewHostMsg_LoadFont, OnLoadFont) #endif #if defined(OS_WIN) // This hack is Windows-specific. - IPC_MESSAGE_HANDLER(ViewHostMsg_PreCacheFont, OnPreCacheFont) + IPC_MESSAGE_HANDLER(ViewHostMsg_PreCacheFont, OnPreCacheFont) #endif - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetPlugins, OnGetPlugins) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetPluginInfo, - OnGetPluginInfo) - IPC_MESSAGE_HANDLER(ViewHostMsg_DownloadUrl, OnDownloadUrl) - IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_ContextMenu, - OnReceiveContextMenuMsg(message)) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_OpenChannelToPlugin, - OnOpenChannelToPlugin) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_OpenChannelToPepperPlugin, - OnOpenChannelToPepperPlugin) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_LaunchNaCl, OnLaunchNaCl) - IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWorker, OnCreateWorker) - IPC_MESSAGE_HANDLER(ViewHostMsg_LookupSharedWorker, OnLookupSharedWorker) - IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentDetached, OnDocumentDetached) - IPC_MESSAGE_HANDLER(ViewHostMsg_CancelCreateDedicatedWorker, - OnCancelCreateDedicatedWorker) - IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToWorker, - OnForwardToWorker) - IPC_MESSAGE_HANDLER(ViewHostMsg_SpellChecker_PlatformCheckSpelling, - OnPlatformCheckSpelling) - IPC_MESSAGE_HANDLER(ViewHostMsg_SpellChecker_PlatformFillSuggestionList, - OnPlatformFillSuggestionList) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetDocumentTag, - OnGetDocumentTag) - IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentWithTagClosed, - OnDocumentWithTagClosed) - IPC_MESSAGE_HANDLER(ViewHostMsg_ShowSpellingPanel, OnShowSpellingPanel) - IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateSpellingPanelWithMisspelledWord, - OnUpdateSpellingPanelWithMisspelledWord) - IPC_MESSAGE_HANDLER(ViewHostMsg_DnsPrefetch, OnDnsPrefetch) - IPC_MESSAGE_HANDLER(ViewHostMsg_RendererHistograms, - OnRendererHistograms) - IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_UpdateRect, - render_widget_helper_->DidReceiveUpdateMsg(message)) - IPC_MESSAGE_HANDLER(ViewHostMsg_ClipboardWriteObjectsAsync, - OnClipboardWriteObjectsAsync) - IPC_MESSAGE_HANDLER(ViewHostMsg_ClipboardWriteObjectsSync, - OnClipboardWriteObjectsSync) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardIsFormatAvailable, - OnClipboardIsFormatAvailable) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadText, - OnClipboardReadText) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadAsciiText, - OnClipboardReadAsciiText) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadHTML, - OnClipboardReadHTML) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetPlugins, OnGetPlugins) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetPluginInfo, OnGetPluginInfo) + IPC_MESSAGE_HANDLER(ViewHostMsg_DownloadUrl, OnDownloadUrl) + IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_ContextMenu, + OnReceiveContextMenuMsg(message)) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_OpenChannelToPlugin, + OnOpenChannelToPlugin) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_OpenChannelToPepperPlugin, + OnOpenChannelToPepperPlugin) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_LaunchNaCl, OnLaunchNaCl) + IPC_MESSAGE_HANDLER(ViewHostMsg_SpellChecker_PlatformCheckSpelling, + OnPlatformCheckSpelling) + IPC_MESSAGE_HANDLER(ViewHostMsg_SpellChecker_PlatformFillSuggestionList, + OnPlatformFillSuggestionList) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetDocumentTag, + OnGetDocumentTag) + IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentWithTagClosed, + OnDocumentWithTagClosed) + IPC_MESSAGE_HANDLER(ViewHostMsg_ShowSpellingPanel, OnShowSpellingPanel) + IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateSpellingPanelWithMisspelledWord, + OnUpdateSpellingPanelWithMisspelledWord) + IPC_MESSAGE_HANDLER(ViewHostMsg_DnsPrefetch, OnDnsPrefetch) + IPC_MESSAGE_HANDLER(ViewHostMsg_RendererHistograms, OnRendererHistograms) + IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_UpdateRect, + render_widget_helper_->DidReceiveUpdateMsg(message)) + IPC_MESSAGE_HANDLER(ViewHostMsg_ClipboardWriteObjectsAsync, + OnClipboardWriteObjectsAsync) + IPC_MESSAGE_HANDLER(ViewHostMsg_ClipboardWriteObjectsSync, + OnClipboardWriteObjectsSync) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardIsFormatAvailable, + OnClipboardIsFormatAvailable) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadText, + OnClipboardReadText) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadAsciiText, + OnClipboardReadAsciiText) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadHTML, + OnClipboardReadHTML) #if defined(OS_MACOSX) - IPC_MESSAGE_HANDLER(ViewHostMsg_ClipboardFindPboardWriteStringAsync, - OnClipboardFindPboardWriteString) + IPC_MESSAGE_HANDLER(ViewHostMsg_ClipboardFindPboardWriteStringAsync, + OnClipboardFindPboardWriteString) #endif - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadAvailableTypes, - OnClipboardReadAvailableTypes) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadData, - OnClipboardReadData) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadFilenames, - OnClipboardReadFilenames) - IPC_MESSAGE_HANDLER(ViewHostMsg_CheckNotificationPermission, - OnCheckNotificationPermission) - IPC_MESSAGE_HANDLER(ViewHostMsg_RevealFolderInOS, OnRevealFolderInOS) - IPC_MESSAGE_HANDLER(ViewHostMsg_GetCPBrowsingContext, - OnGetCPBrowsingContext) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadAvailableTypes, + OnClipboardReadAvailableTypes) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadData, + OnClipboardReadData) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClipboardReadFilenames, + OnClipboardReadFilenames) + IPC_MESSAGE_HANDLER(ViewHostMsg_CheckNotificationPermission, + OnCheckNotificationPermission) + IPC_MESSAGE_HANDLER(ViewHostMsg_RevealFolderInOS, OnRevealFolderInOS) + IPC_MESSAGE_HANDLER(ViewHostMsg_GetCPBrowsingContext, + OnGetCPBrowsingContext) #if defined(OS_WIN) - IPC_MESSAGE_HANDLER(ViewHostMsg_DuplicateSection, OnDuplicateSection) + IPC_MESSAGE_HANDLER(ViewHostMsg_DuplicateSection, OnDuplicateSection) #endif #if defined(OS_POSIX) - IPC_MESSAGE_HANDLER(ViewHostMsg_AllocateSharedMemoryBuffer, - OnAllocateSharedMemoryBuffer) + IPC_MESSAGE_HANDLER(ViewHostMsg_AllocateSharedMemoryBuffer, + OnAllocateSharedMemoryBuffer) #endif #if defined(OS_POSIX) && !defined(OS_MACOSX) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_AllocateTempFileForPrinting, - OnAllocateTempFileForPrinting) - IPC_MESSAGE_HANDLER(ViewHostMsg_TempFileForPrintingWritten, - OnTempFileForPrintingWritten) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_AllocateTempFileForPrinting, + OnAllocateTempFileForPrinting) + IPC_MESSAGE_HANDLER(ViewHostMsg_TempFileForPrintingWritten, + OnTempFileForPrintingWritten) #endif - IPC_MESSAGE_HANDLER(ViewHostMsg_ResourceTypeStats, OnResourceTypeStats) - IPC_MESSAGE_HANDLER(ViewHostMsg_V8HeapStats, OnV8HeapStats) - IPC_MESSAGE_HANDLER(ViewHostMsg_DidZoomURL, OnDidZoomURL) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ResolveProxy, OnResolveProxy) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetDefaultPrintSettings, - OnGetDefaultPrintSettings) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ScriptedPrint, - OnScriptedPrint) + IPC_MESSAGE_HANDLER(ViewHostMsg_ResourceTypeStats, OnResourceTypeStats) + IPC_MESSAGE_HANDLER(ViewHostMsg_V8HeapStats, OnV8HeapStats) + IPC_MESSAGE_HANDLER(ViewHostMsg_DidZoomURL, OnDidZoomURL) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ResolveProxy, OnResolveProxy) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetDefaultPrintSettings, + OnGetDefaultPrintSettings) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ScriptedPrint, OnScriptedPrint) #if defined(OS_MACOSX) - IPC_MESSAGE_HANDLER(ViewHostMsg_AllocTransportDIB, - OnAllocTransportDIB) - IPC_MESSAGE_HANDLER(ViewHostMsg_FreeTransportDIB, - OnFreeTransportDIB) + IPC_MESSAGE_HANDLER(ViewHostMsg_AllocTransportDIB, OnAllocTransportDIB) + IPC_MESSAGE_HANDLER(ViewHostMsg_FreeTransportDIB, OnFreeTransportDIB) #endif - IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToExtension, - OnOpenChannelToExtension) - IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToTab, OnOpenChannelToTab) - IPC_MESSAGE_HANDLER(ViewHostMsg_CloseCurrentConnections, - OnCloseCurrentConnections) - IPC_MESSAGE_HANDLER(ViewHostMsg_SetCacheMode, OnSetCacheMode) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClearCache, OnClearCache) - IPC_MESSAGE_HANDLER(ViewHostMsg_DidGenerateCacheableMetadata, - OnCacheableMetadataAvailable) - IPC_MESSAGE_HANDLER(ViewHostMsg_EnableSpdy, OnEnableSpdy) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_Keygen, OnKeygen) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetExtensionMessageBundle, - OnGetExtensionMessageBundle) + IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToExtension, + OnOpenChannelToExtension) + IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToTab, OnOpenChannelToTab) + IPC_MESSAGE_HANDLER(ViewHostMsg_CloseCurrentConnections, + OnCloseCurrentConnections) + IPC_MESSAGE_HANDLER(ViewHostMsg_SetCacheMode, OnSetCacheMode) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_ClearCache, OnClearCache) + IPC_MESSAGE_HANDLER(ViewHostMsg_DidGenerateCacheableMetadata, + OnCacheableMetadataAvailable) + IPC_MESSAGE_HANDLER(ViewHostMsg_EnableSpdy, OnEnableSpdy) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_Keygen, OnKeygen) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetExtensionMessageBundle, + OnGetExtensionMessageBundle) #if defined(USE_TCMALLOC) - IPC_MESSAGE_HANDLER(ViewHostMsg_RendererTcmalloc, OnRendererTcmalloc) + IPC_MESSAGE_HANDLER(ViewHostMsg_RendererTcmalloc, OnRendererTcmalloc) #endif - IPC_MESSAGE_HANDLER(ViewHostMsg_EstablishGpuChannel, - OnEstablishGpuChannel) - IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_SynchronizeGpu, - OnSynchronizeGpu) - IPC_MESSAGE_HANDLER(ViewHostMsg_AsyncOpenFile, OnAsyncOpenFile) - IPC_MESSAGE_UNHANDLED(handled = false) - IPC_END_MESSAGE_MAP_EX() - } + IPC_MESSAGE_HANDLER(ViewHostMsg_EstablishGpuChannel, OnEstablishGpuChannel) + IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_SynchronizeGpu, + OnSynchronizeGpu) + IPC_MESSAGE_HANDLER(ViewHostMsg_AsyncOpenFile, OnAsyncOpenFile) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP_EX() return handled; } @@ -771,50 +723,6 @@ void RenderMessageFilter::OnLaunchNaCl( host->Launch(this, channel_descriptor, reply_msg); } -void RenderMessageFilter::OnCreateWorker( - const ViewHostMsg_CreateWorker_Params& params, int* route_id) { - *route_id = params.route_id != MSG_ROUTING_NONE ? - params.route_id : render_widget_helper_->GetNextRoutingID(); - if (params.is_shared) - WorkerService::GetInstance()->CreateSharedWorker( - params.url, off_the_record(), params.name, - params.document_id, render_process_id_, params.render_view_route_id, - this, *route_id, params.script_resource_appcache_id, - static_cast<ChromeURLRequestContext*>( - request_context_->GetURLRequestContext())); - else - WorkerService::GetInstance()->CreateDedicatedWorker( - params.url, off_the_record(), - params.document_id, render_process_id_, params.render_view_route_id, - this, *route_id, render_process_id_, params.parent_appcache_host_id, - static_cast<ChromeURLRequestContext*>( - request_context_->GetURLRequestContext())); -} - -void RenderMessageFilter::OnLookupSharedWorker( - const ViewHostMsg_CreateWorker_Params& params, bool* exists, int* route_id, - bool* url_mismatch) { - *route_id = render_widget_helper_->GetNextRoutingID(); - *exists = WorkerService::GetInstance()->LookupSharedWorker( - params.url, params.name, off_the_record(), params.document_id, - render_process_id_, params.render_view_route_id, this, *route_id, - url_mismatch); -} - -void RenderMessageFilter::OnDocumentDetached(unsigned long long document_id) { - // Notify the WorkerService that the passed document was detached so any - // associated shared workers can be shut down. - WorkerService::GetInstance()->DocumentDetached(this, document_id); -} - -void RenderMessageFilter::OnCancelCreateDedicatedWorker(int route_id) { - WorkerService::GetInstance()->CancelCreateDedicatedWorker(this, route_id); -} - -void RenderMessageFilter::OnForwardToWorker(const IPC::Message& message) { - WorkerService::GetInstance()->ForwardMessage(message, this); -} - void RenderMessageFilter::OnDownloadUrl(const IPC::Message& message, const GURL& url, const GURL& referrer) { diff --git a/chrome/browser/renderer_host/render_message_filter.h b/chrome/browser/renderer_host/render_message_filter.h index 5c988b8..98e8402 100644 --- a/chrome/browser/renderer_host/render_message_filter.h +++ b/chrome/browser/renderer_host/render_message_filter.h @@ -15,7 +15,6 @@ #include "app/clipboard/clipboard.h" #include "app/surface/transport_dib.h" -#include "base/callback.h" #include "base/file_path.h" #include "base/linked_ptr.h" #include "base/string16.h" @@ -75,8 +74,6 @@ class RenderMessageFilter : public BrowserMessageFilter, RenderWidgetHelper* render_widget_helper); // BrowserMessageFilter methods: - virtual void OnChannelConnected(int32 peer_pid); - virtual void OnChannelError(); virtual bool OnMessageReceived(const IPC::Message& message, bool* message_was_ok); virtual void OnDestruct() const; @@ -86,9 +83,6 @@ class RenderMessageFilter : public BrowserMessageFilter, return resource_dispatcher_host_; } bool off_the_record() { return off_the_record_; } - CallbackWithReturnValue<int>::Type* next_route_id_callback() { - return next_route_id_callback_.get(); - } // Returns either the extension URLRequestContext or regular URLRequestContext // depending on whether |url| is an extension URL. @@ -170,15 +164,6 @@ class RenderMessageFilter : public BrowserMessageFilter, void OnLaunchNaCl(const std::wstring& url, int channel_descriptor, IPC::Message* reply_msg); - void OnCreateWorker(const ViewHostMsg_CreateWorker_Params& params, - int* route_id); - void OnLookupSharedWorker(const ViewHostMsg_CreateWorker_Params& params, - bool* exists, - int* route_id, - bool* url_error); - void OnDocumentDetached(unsigned long long document_id); - void OnCancelCreateDedicatedWorker(int route_id); - void OnForwardToWorker(const IPC::Message& msg); void OnDownloadUrl(const IPC::Message& message, const GURL& url, const GURL& referrer); @@ -424,9 +409,6 @@ class RenderMessageFilter : public BrowserMessageFilter, // A list of all Ppapi plugin processes for this renderer. std::vector<linked_ptr<PpapiPluginProcessHost> > ppapi_plugin_hosts_; - // A callback to create a routing id for the associated renderer process. - scoped_ptr<CallbackWithReturnValue<int>::Type> next_route_id_callback_; - scoped_refptr<WebKitContext> webkit_context_; int render_process_id_; diff --git a/chrome/browser/renderer_host/render_widget_host.cc b/chrome/browser/renderer_host/render_widget_host.cc index b4bb0e2..f530697 100644 --- a/chrome/browser/renderer_host/render_widget_host.cc +++ b/chrome/browser/renderer_host/render_widget_host.cc @@ -391,8 +391,7 @@ BackingStore* RenderWidgetHost::GetBackingStore(bool force_create) { IPC::Message msg; TimeDelta max_delay = TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS); if (process_->WaitForUpdateMsg(routing_id_, max_delay, &msg)) { - ViewHostMsg_UpdateRect::Dispatch( - &msg, this, &RenderWidgetHost::OnMsgUpdateRect); + OnMessageReceived(msg); backing_store = BackingStoreManager::GetBackingStore(this, current_size_); } } @@ -427,10 +426,8 @@ void RenderWidgetHost::ScheduleComposite() { // We always block on response because we do not have a backing store. IPC::Message msg; TimeDelta max_delay = TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS); - if (process_->WaitForUpdateMsg(routing_id_, max_delay, &msg)) { - ViewHostMsg_UpdateRect::Dispatch( - &msg, this, &RenderWidgetHost::OnMsgUpdateRect); - } + if (process_->WaitForUpdateMsg(routing_id_, max_delay, &msg)) + OnMessageReceived(msg); } void RenderWidgetHost::StartHangMonitorTimeout(TimeDelta delay) { diff --git a/chrome/browser/renderer_host/resource_dispatcher_host.cc b/chrome/browser/renderer_host/resource_dispatcher_host.cc index 1d073d3..cad4560 100644 --- a/chrome/browser/renderer_host/resource_dispatcher_host.cc +++ b/chrome/browser/renderer_host/resource_dispatcher_host.cc @@ -1518,20 +1518,14 @@ bool ResourceDispatcherHost::RenderViewForRequest( // If the request is from the worker process, find a tab that owns the worker. if (info->process_type() == ChildProcessInfo::WORKER_PROCESS) { - const WorkerProcessHost::WorkerInstance* worker_instance = - WorkerService::GetInstance()->FindWorkerInstance(info->child_id()); - if (!worker_instance) { + // Need to display some related UI for this network request - pick an + // arbitrary parent to do so. + if (!WorkerService::GetInstance()->GetRendererForWorker( + info->child_id(), render_process_host_id, render_view_host_id)) { *render_process_host_id = -1; *render_view_host_id = -1; return false; } - DCHECK(!worker_instance->worker_document_set()->IsEmpty()); - const WorkerDocumentSet::DocumentInfoSet& parents = - worker_instance->worker_document_set()->documents(); - // Need to display some related UI for this network request - pick an - // arbitrary parent to do so. - *render_process_host_id = parents.begin()->renderer_id(); - *render_view_host_id = parents.begin()->render_view_route_id(); } else { *render_process_host_id = info->child_id(); *render_view_host_id = info->route_id(); diff --git a/chrome/browser/renderer_host/resource_request_details.cc b/chrome/browser/renderer_host/resource_request_details.cc index 6facdd6..07183d4 100644 --- a/chrome/browser/renderer_host/resource_request_details.cc +++ b/chrome/browser/renderer_host/resource_request_details.cc @@ -4,6 +4,8 @@ #include "chrome/browser/renderer_host/resource_request_details.h" +#include "chrome/browser/worker_host/worker_service.h" + ResourceRequestDetails::ResourceRequestDetails(const net::URLRequest* request, int cert_id) : url_(request->url()), @@ -25,18 +27,13 @@ ResourceRequestDetails::ResourceRequestDetails(const net::URLRequest* request, // If request is from the worker process on behalf of a renderer, use // the renderer process id, since it consumes the notification response // such as ssl state etc. - const WorkerProcessHost::WorkerInstance* worker_instance = - WorkerService::GetInstance()->FindWorkerInstance(info->child_id()); - if (worker_instance) { - DCHECK(!worker_instance->worker_document_set()->IsEmpty()); - const WorkerDocumentSet::DocumentInfoSet& parents = - worker_instance->worker_document_set()->documents(); - // TODO(atwilson): need to notify all associated renderers in the case - // of ssl state change (http://crbug.com/25357). For now, just notify - // the first one (works for dedicated workers and shared workers with - // a single process). - origin_child_id_ = parents.begin()->renderer_id(); - } else { + // TODO(atwilson): need to notify all associated renderers in the case + // of ssl state change (http://crbug.com/25357). For now, just notify + // the first one (works for dedicated workers and shared workers with + // a single process). + int temp; + if (!WorkerService::GetInstance()->GetRendererForWorker( + info->child_id(), &origin_child_id_, &temp)) { origin_child_id_ = info->child_id(); } } diff --git a/chrome/browser/renderer_host/safe_browsing_resource_handler.cc b/chrome/browser/renderer_host/safe_browsing_resource_handler.cc index d73f24b0..237cad8 100644 --- a/chrome/browser/renderer_host/safe_browsing_resource_handler.cc +++ b/chrome/browser/renderer_host/safe_browsing_resource_handler.cc @@ -6,10 +6,8 @@ #include "base/logging.h" #include "chrome/browser/renderer_host/global_request_id.h" -#include "chrome/browser/renderer_host/render_message_filter.h" #include "chrome/browser/renderer_host/resource_dispatcher_host.h" #include "chrome/browser/renderer_host/resource_message_filter.h" -#include "chrome/common/notification_service.h" #include "chrome/common/resource_response.h" #include "net/base/net_errors.h" #include "net/base/io_buffer.h" @@ -38,8 +36,6 @@ SafeBrowsingResourceHandler::SafeBrowsingResourceHandler( safe_browsing_(safe_browsing), rdh_(resource_dispatcher_host), resource_type_(resource_type) { - registrar_.Add(this, NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN, - NotificationService::AllSources()); } SafeBrowsingResourceHandler::~SafeBrowsingResourceHandler() { @@ -204,15 +200,6 @@ void SafeBrowsingResourceHandler::OnBlockingPageComplete(bool proceed) { Release(); // Balances the AddRef() in StartDisplayingBlockingPage(). } -void SafeBrowsingResourceHandler::Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details) { - if (Source<ResourceMessageFilter>(source).ptr()->child_id() == - render_process_host_id_) { - Shutdown(); - } -} - void SafeBrowsingResourceHandler::Shutdown() { if (state_ == STATE_CHECKING_URL) { timer_.Stop(); diff --git a/chrome/browser/renderer_host/safe_browsing_resource_handler.h b/chrome/browser/renderer_host/safe_browsing_resource_handler.h index e679fdc..724297f 100644 --- a/chrome/browser/renderer_host/safe_browsing_resource_handler.h +++ b/chrome/browser/renderer_host/safe_browsing_resource_handler.h @@ -13,8 +13,6 @@ #include "base/timer.h" #include "chrome/browser/renderer_host/resource_handler.h" #include "chrome/browser/safe_browsing/safe_browsing_service.h" -#include "chrome/common/notification_observer.h" -#include "chrome/common/notification_registrar.h" class ResourceDispatcherHost; @@ -41,8 +39,7 @@ class ResourceDispatcherHost; // If on the other hand the URL was decided to be safe, the request is // resumed. class SafeBrowsingResourceHandler : public ResourceHandler, - public SafeBrowsingService::Client, - public NotificationObserver { + public SafeBrowsingService::Client { public: SafeBrowsingResourceHandler(ResourceHandler* handler, int render_process_host_id, @@ -74,11 +71,6 @@ class SafeBrowsingResourceHandler : public ResourceHandler, // the user has decided to proceed with the current request, or go back. virtual void OnBlockingPageComplete(bool proceed); - // NotificationObserver interface. - virtual void Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details); - private: // Describes what phase of the check a handler is in. enum State { @@ -145,7 +137,6 @@ class SafeBrowsingResourceHandler : public ResourceHandler, int deferred_request_id_; scoped_refptr<ResourceResponse> deferred_redirect_response_; - NotificationRegistrar registrar_; scoped_refptr<ResourceHandler> next_handler_; int render_process_host_id_; int render_view_id_; diff --git a/chrome/browser/worker_host/message_port_dispatcher.cc b/chrome/browser/worker_host/message_port_dispatcher.cc deleted file mode 100644 index 1be8369..0000000 --- a/chrome/browser/worker_host/message_port_dispatcher.cc +++ /dev/null @@ -1,291 +0,0 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "chrome/browser/worker_host/message_port_dispatcher.h" - -#include "base/callback.h" -#include "base/singleton.h" -#include "chrome/browser/renderer_host/render_message_filter.h" -#include "chrome/browser/worker_host/worker_process_host.h" -#include "chrome/common/notification_service.h" -#include "chrome/common/worker_messages.h" - -struct MessagePortDispatcher::MessagePort { - // sender and route_id are what we need to send messages to the port. - IPC::Message::Sender* sender; - int route_id; - // A function pointer to generate a new route id for the sender above. - // Owned by "sender" above, so don't delete. - CallbackWithReturnValue<int>::Type* next_routing_id; - // A globally unique id for this message port. - int message_port_id; - // The globally unique id of the entangled message port. - int entangled_message_port_id; - // If true, all messages to this message port are queued and not delivered. - bool queue_messages; - QueuedMessages queued_messages; -}; - -MessagePortDispatcher* MessagePortDispatcher::GetInstance() { - return Singleton<MessagePortDispatcher>::get(); -} - -MessagePortDispatcher::MessagePortDispatcher() - : next_message_port_id_(0), - sender_(NULL), - next_routing_id_(NULL) { - // Receive a notification if a message filter or WorkerProcessHost is deleted. - registrar_.Add(this, NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN, - NotificationService::AllSources()); - - registrar_.Add(this, NotificationType::WORKER_PROCESS_HOST_SHUTDOWN, - NotificationService::AllSources()); -} - -MessagePortDispatcher::~MessagePortDispatcher() { -} - -bool MessagePortDispatcher::OnMessageReceived( - const IPC::Message& message, - IPC::Message::Sender* sender, - CallbackWithReturnValue<int>::Type* next_routing_id, - bool* message_was_ok) { - sender_ = sender; - next_routing_id_ = next_routing_id; - - bool handled = true; - *message_was_ok = true; - - IPC_BEGIN_MESSAGE_MAP_EX(MessagePortDispatcher, message, *message_was_ok) - IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_CreateMessagePort, OnCreate) - IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_DestroyMessagePort, OnDestroy) - IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_Entangle, OnEntangle) - IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_PostMessage, OnPostMessage) - IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_QueueMessages, OnQueueMessages) - IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_SendQueuedMessages, - OnSendQueuedMessages) - IPC_MESSAGE_UNHANDLED(handled = false) - IPC_END_MESSAGE_MAP_EX() - - sender_ = NULL; - next_routing_id_ = NULL; - - return handled; -} - -void MessagePortDispatcher::UpdateMessagePort( - int message_port_id, - IPC::Message::Sender* sender, - int routing_id, - CallbackWithReturnValue<int>::Type* next_routing_id) { - if (!message_ports_.count(message_port_id)) { - NOTREACHED(); - return; - } - - MessagePort& port = message_ports_[message_port_id]; - port.sender = sender; - port.route_id = routing_id; - port.next_routing_id = next_routing_id; -} - -bool MessagePortDispatcher::Send(IPC::Message* message) { - return sender_->Send(message); -} - -void MessagePortDispatcher::OnCreate(int *route_id, - int* message_port_id) { - *message_port_id = ++next_message_port_id_; - *route_id = next_routing_id_->Run(); - - MessagePort port; - port.sender = sender_; - port.route_id = *route_id; - port.next_routing_id = next_routing_id_; - port.message_port_id = *message_port_id; - port.entangled_message_port_id = MSG_ROUTING_NONE; - port.queue_messages = false; - message_ports_[*message_port_id] = port; -} - -void MessagePortDispatcher::OnDestroy(int message_port_id) { - if (!message_ports_.count(message_port_id)) { - NOTREACHED(); - return; - } - - DCHECK(message_ports_[message_port_id].queued_messages.empty()); - Erase(message_port_id); -} - -void MessagePortDispatcher::OnEntangle(int local_message_port_id, - int remote_message_port_id) { - if (!message_ports_.count(local_message_port_id) || - !message_ports_.count(remote_message_port_id)) { - NOTREACHED(); - return; - } - - DCHECK(message_ports_[remote_message_port_id].entangled_message_port_id == - MSG_ROUTING_NONE); - message_ports_[remote_message_port_id].entangled_message_port_id = - local_message_port_id; -} - -void MessagePortDispatcher::OnPostMessage( - int sender_message_port_id, - const string16& message, - const std::vector<int>& sent_message_port_ids) { - if (!message_ports_.count(sender_message_port_id)) { - NOTREACHED(); - return; - } - - int entangled_message_port_id = - message_ports_[sender_message_port_id].entangled_message_port_id; - if (entangled_message_port_id == MSG_ROUTING_NONE) - return; // Process could have crashed. - - if (!message_ports_.count(entangled_message_port_id)) { - NOTREACHED(); - return; - } - - PostMessageTo(entangled_message_port_id, message, sent_message_port_ids); -} - -void MessagePortDispatcher::PostMessageTo( - int message_port_id, - const string16& message, - const std::vector<int>& sent_message_port_ids) { - if (!message_ports_.count(message_port_id)) { - NOTREACHED(); - return; - } - for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { - if (!message_ports_.count(sent_message_port_ids[i])) { - NOTREACHED(); - return; - } - } - - MessagePort& entangled_port = message_ports_[message_port_id]; - - std::vector<MessagePort*> sent_ports(sent_message_port_ids.size()); - for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { - sent_ports[i] = &message_ports_[sent_message_port_ids[i]]; - sent_ports[i]->queue_messages = true; - } - - if (entangled_port.queue_messages) { - entangled_port.queued_messages.push_back( - std::make_pair(message, sent_message_port_ids)); - } else { - // If a message port was sent around, the new location will need a routing - // id. Instead of having the created port send us a sync message to get it, - // send along with the message. - std::vector<int> new_routing_ids(sent_message_port_ids.size()); - for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { - new_routing_ids[i] = entangled_port.next_routing_id->Run(); - sent_ports[i]->sender = entangled_port.sender; - - // Update the entry for the sent port as it can be in a different process. - sent_ports[i]->route_id = new_routing_ids[i]; - } - - if (entangled_port.sender) { - // Now send the message to the entangled port. - IPC::Message* ipc_msg = new WorkerProcessMsg_Message( - entangled_port.route_id, message, sent_message_port_ids, - new_routing_ids); - entangled_port.sender->Send(ipc_msg); - } - } -} - -void MessagePortDispatcher::OnQueueMessages(int message_port_id) { - if (!message_ports_.count(message_port_id)) { - NOTREACHED(); - return; - } - - MessagePort& port = message_ports_[message_port_id]; - if (port.sender) { - port.sender->Send(new WorkerProcessMsg_MessagesQueued(port.route_id)); - port.queue_messages = true; - port.sender = NULL; - } -} - -void MessagePortDispatcher::OnSendQueuedMessages( - int message_port_id, - const QueuedMessages& queued_messages) { - if (!message_ports_.count(message_port_id)) { - NOTREACHED(); - return; - } - - // Send the queued messages to the port again. This time they'll reach the - // new location. - MessagePort& port = message_ports_[message_port_id]; - port.queue_messages = false; - port.queued_messages.insert(port.queued_messages.begin(), - queued_messages.begin(), - queued_messages.end()); - SendQueuedMessagesIfPossible(message_port_id); -} - -void MessagePortDispatcher::SendQueuedMessagesIfPossible(int message_port_id) { - if (!message_ports_.count(message_port_id)) { - NOTREACHED(); - return; - } - - MessagePort& port = message_ports_[message_port_id]; - if (port.queue_messages || !port.sender) - return; - - for (QueuedMessages::iterator iter = port.queued_messages.begin(); - iter != port.queued_messages.end(); ++iter) { - PostMessageTo(message_port_id, iter->first, iter->second); - } - port.queued_messages.clear(); -} - -void MessagePortDispatcher::Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details) { - IPC::Message::Sender* sender = NULL; - if (type.value == NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN) { - sender = Source<RenderMessageFilter>(source).ptr(); - } else if (type.value == NotificationType::WORKER_PROCESS_HOST_SHUTDOWN) { - sender = Source<WorkerProcessHost>(source).ptr(); - } else { - NOTREACHED(); - } - - // Check if the (possibly) crashed process had any message ports. - for (MessagePorts::iterator iter = message_ports_.begin(); - iter != message_ports_.end();) { - MessagePorts::iterator cur_item = iter++; - if (cur_item->second.sender == sender) { - Erase(cur_item->first); - } - } -} - -void MessagePortDispatcher::Erase(int message_port_id) { - MessagePorts::iterator erase_item = message_ports_.find(message_port_id); - DCHECK(erase_item != message_ports_.end()); - - int entangled_id = erase_item->second.entangled_message_port_id; - if (entangled_id != MSG_ROUTING_NONE) { - // Do the disentanglement (and be paranoid about the other side existing - // just in case something unusual happened during entanglement). - if (message_ports_.count(entangled_id)) { - message_ports_[entangled_id].entangled_message_port_id = MSG_ROUTING_NONE; - } - } - message_ports_.erase(erase_item); -} diff --git a/chrome/browser/worker_host/message_port_dispatcher.h b/chrome/browser/worker_host/message_port_dispatcher.h deleted file mode 100644 index 4c71283..0000000 --- a/chrome/browser/worker_host/message_port_dispatcher.h +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef CHROME_BROWSER_WORKER_HOST_MESSAGE_PORT_DISPATCHER_H_ -#define CHROME_BROWSER_WORKER_HOST_MESSAGE_PORT_DISPATCHER_H_ -#pragma once - -#include <map> -#include <utility> -#include <vector> - -#include "base/basictypes.h" -#include "base/callback.h" -#include "base/singleton.h" -#include "base/string16.h" -#include "base/task.h" -#include "chrome/common/notification_observer.h" -#include "chrome/common/notification_registrar.h" -#include "ipc/ipc_message.h" - -class MessagePortDispatcher : public NotificationObserver { - public: - typedef std::vector<std::pair<string16, std::vector<int> > > QueuedMessages; - - // Returns the MessagePortDispatcher singleton. - static MessagePortDispatcher* GetInstance(); - - bool OnMessageReceived(const IPC::Message& message, - IPC::Message::Sender* sender, - CallbackWithReturnValue<int>::Type* next_routing_id, - bool* message_was_ok); - - // Updates the information needed to reach a message port when it's sent to a - // (possibly different) process. - void UpdateMessagePort( - int message_port_id, - IPC::Message::Sender* sender, - int routing_id, - CallbackWithReturnValue<int>::Type* next_routing_id); - - // Attempts to send the queued messages for a message port. - void SendQueuedMessagesIfPossible(int message_port_id); - - bool Send(IPC::Message* message); - - private: - friend struct DefaultSingletonTraits<MessagePortDispatcher>; - - MessagePortDispatcher(); - ~MessagePortDispatcher(); - - // Message handlers. - void OnCreate(int* route_id, int* message_port_id); - void OnDestroy(int message_port_id); - void OnEntangle(int local_message_port_id, int remote_message_port_id); - void OnPostMessage(int sender_message_port_id, - const string16& message, - const std::vector<int>& sent_message_port_ids); - void OnQueueMessages(int message_port_id); - void OnSendQueuedMessages(int message_port_id, - const QueuedMessages& queued_messages); - - void PostMessageTo(int message_port_id, - const string16& message, - const std::vector<int>& sent_message_port_ids); - - // NotificationObserver interface. - virtual void Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details); - - // Handles the details of removing a message port id. Before calling this, - // verify that the message port id exists. - void Erase(int message_port_id); - - struct MessagePort; - typedef std::map<int, MessagePort> MessagePorts; - MessagePorts message_ports_; - - // We need globally unique identifiers for each message port. - int next_message_port_id_; - - // Valid only during IPC message dispatching. - IPC::Message::Sender* sender_; - CallbackWithReturnValue<int>::Type* next_routing_id_; - - NotificationRegistrar registrar_; - - DISALLOW_COPY_AND_ASSIGN(MessagePortDispatcher); -}; - -#endif // CHROME_BROWSER_WORKER_HOST_MESSAGE_PORT_DISPATCHER_H_ diff --git a/chrome/browser/worker_host/message_port_service.cc b/chrome/browser/worker_host/message_port_service.cc new file mode 100644 index 0000000..6638e71 --- /dev/null +++ b/chrome/browser/worker_host/message_port_service.cc @@ -0,0 +1,236 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "chrome/browser/worker_host/message_port_service.h" + +#include "chrome/browser/worker_host/worker_message_filter.h" +#include "chrome/common/worker_messages.h" + +struct MessagePortService::MessagePort { + // |filter| and |route_id| are what we need to send messages to the port. + // |filter| is just a weak pointer since we get notified when its process has + // gone away and remove it. + WorkerMessageFilter* filter; + int route_id; + // A globally unique id for this message port. + int message_port_id; + // The globally unique id of the entangled message port. + int entangled_message_port_id; + // If true, all messages to this message port are queued and not delivered. + bool queue_messages; + QueuedMessages queued_messages; +}; + +MessagePortService* MessagePortService::GetInstance() { + return Singleton<MessagePortService>::get(); +} + +MessagePortService::MessagePortService() + : next_message_port_id_(0) { +} + +MessagePortService::~MessagePortService() { +} + +void MessagePortService::UpdateMessagePort( + int message_port_id, + WorkerMessageFilter* filter, + int routing_id) { + if (!message_ports_.count(message_port_id)) { + NOTREACHED(); + return; + } + + MessagePort& port = message_ports_[message_port_id]; + port.filter = filter; + port.route_id = routing_id; +} + +void MessagePortService::OnWorkerMessageFilterClosing( + WorkerMessageFilter* filter) { + // Check if the (possibly) crashed process had any message ports. + for (MessagePorts::iterator iter = message_ports_.begin(); + iter != message_ports_.end();) { + MessagePorts::iterator cur_item = iter++; + if (cur_item->second.filter == filter) { + Erase(cur_item->first); + } + } +} + +void MessagePortService::Create(int route_id, + WorkerMessageFilter* filter, + int* message_port_id) { + *message_port_id = ++next_message_port_id_; + + MessagePort port; + port.filter = filter; + port.route_id = route_id; + port.message_port_id = *message_port_id; + port.entangled_message_port_id = MSG_ROUTING_NONE; + port.queue_messages = false; + message_ports_[*message_port_id] = port; +} + +void MessagePortService::Destroy(int message_port_id) { + if (!message_ports_.count(message_port_id)) { + NOTREACHED(); + return; + } + + DCHECK(message_ports_[message_port_id].queued_messages.empty()); + Erase(message_port_id); +} + +void MessagePortService::Entangle(int local_message_port_id, + int remote_message_port_id) { + if (!message_ports_.count(local_message_port_id) || + !message_ports_.count(remote_message_port_id)) { + NOTREACHED(); + return; + } + + DCHECK(message_ports_[remote_message_port_id].entangled_message_port_id == + MSG_ROUTING_NONE); + message_ports_[remote_message_port_id].entangled_message_port_id = + local_message_port_id; +} + +void MessagePortService::PostMessage( + int sender_message_port_id, + const string16& message, + const std::vector<int>& sent_message_port_ids) { + if (!message_ports_.count(sender_message_port_id)) { + NOTREACHED(); + return; + } + + int entangled_message_port_id = + message_ports_[sender_message_port_id].entangled_message_port_id; + if (entangled_message_port_id == MSG_ROUTING_NONE) + return; // Process could have crashed. + + if (!message_ports_.count(entangled_message_port_id)) { + NOTREACHED(); + return; + } + + PostMessageTo(entangled_message_port_id, message, sent_message_port_ids); +} + +void MessagePortService::PostMessageTo( + int message_port_id, + const string16& message, + const std::vector<int>& sent_message_port_ids) { + if (!message_ports_.count(message_port_id)) { + NOTREACHED(); + return; + } + for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { + if (!message_ports_.count(sent_message_port_ids[i])) { + NOTREACHED(); + return; + } + } + + MessagePort& entangled_port = message_ports_[message_port_id]; + + std::vector<MessagePort*> sent_ports(sent_message_port_ids.size()); + for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { + sent_ports[i] = &message_ports_[sent_message_port_ids[i]]; + sent_ports[i]->queue_messages = true; + } + + if (entangled_port.queue_messages) { + entangled_port.queued_messages.push_back( + std::make_pair(message, sent_message_port_ids)); + return; + } + + if (!entangled_port.filter) { + NOTREACHED(); + return; + } + + // If a message port was sent around, the new location will need a routing + // id. Instead of having the created port send us a sync message to get it, + // send along with the message. + std::vector<int> new_routing_ids(sent_message_port_ids.size()); + for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { + new_routing_ids[i] = entangled_port.filter->GetNextRoutingID(); + sent_ports[i]->filter = entangled_port.filter; + + // Update the entry for the sent port as it can be in a different process. + sent_ports[i]->route_id = new_routing_ids[i]; + } + + // Now send the message to the entangled port. + entangled_port.filter->Send(new WorkerProcessMsg_Message( + entangled_port.route_id, message, sent_message_port_ids, + new_routing_ids)); +} + +void MessagePortService::QueueMessages(int message_port_id) { + if (!message_ports_.count(message_port_id)) { + NOTREACHED(); + return; + } + + MessagePort& port = message_ports_[message_port_id]; + if (port.filter) { + port.filter->Send(new WorkerProcessMsg_MessagesQueued(port.route_id)); + port.queue_messages = true; + port.filter = NULL; + } +} + +void MessagePortService::SendQueuedMessages( + int message_port_id, + const QueuedMessages& queued_messages) { + if (!message_ports_.count(message_port_id)) { + NOTREACHED(); + return; + } + + // Send the queued messages to the port again. This time they'll reach the + // new location. + MessagePort& port = message_ports_[message_port_id]; + port.queue_messages = false; + port.queued_messages.insert(port.queued_messages.begin(), + queued_messages.begin(), + queued_messages.end()); + SendQueuedMessagesIfPossible(message_port_id); +} + +void MessagePortService::SendQueuedMessagesIfPossible(int message_port_id) { + if (!message_ports_.count(message_port_id)) { + NOTREACHED(); + return; + } + + MessagePort& port = message_ports_[message_port_id]; + if (port.queue_messages || !port.filter) + return; + + for (QueuedMessages::iterator iter = port.queued_messages.begin(); + iter != port.queued_messages.end(); ++iter) { + PostMessageTo(message_port_id, iter->first, iter->second); + } + port.queued_messages.clear(); +} + +void MessagePortService::Erase(int message_port_id) { + MessagePorts::iterator erase_item = message_ports_.find(message_port_id); + DCHECK(erase_item != message_ports_.end()); + + int entangled_id = erase_item->second.entangled_message_port_id; + if (entangled_id != MSG_ROUTING_NONE) { + // Do the disentanglement (and be paranoid about the other side existing + // just in case something unusual happened during entanglement). + if (message_ports_.count(entangled_id)) { + message_ports_[entangled_id].entangled_message_port_id = MSG_ROUTING_NONE; + } + } + message_ports_.erase(erase_item); +} diff --git a/chrome/browser/worker_host/message_port_service.h b/chrome/browser/worker_host/message_port_service.h new file mode 100644 index 0000000..9c30b6e --- /dev/null +++ b/chrome/browser/worker_host/message_port_service.h @@ -0,0 +1,75 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CHROME_BROWSER_WORKER_HOST_MESSAGE_PORT_SERVICE_H_ +#define CHROME_BROWSER_WORKER_HOST_MESSAGE_PORT_SERVICE_H_ +#pragma once + +#include <map> +#include <utility> +#include <vector> + +#include "base/basictypes.h" +#include "base/singleton.h" +#include "base/string16.h" +#include "base/task.h" +#include "ipc/ipc_message.h" + +class WorkerMessageFilter; + +class MessagePortService { + public: + typedef std::vector<std::pair<string16, std::vector<int> > > QueuedMessages; + + // Returns the MessagePortService singleton. + static MessagePortService* GetInstance(); + + // These methods correspond to the message port related IPCs. + void Create(int route_id, WorkerMessageFilter* filter, int* message_port_id); + void Destroy(int message_port_id); + void Entangle(int local_message_port_id, int remote_message_port_id); + void PostMessage(int sender_message_port_id, + const string16& message, + const std::vector<int>& sent_message_port_ids); + void QueueMessages(int message_port_id); + void SendQueuedMessages(int message_port_id, + const QueuedMessages& queued_messages); + + // Updates the information needed to reach a message port when it's sent to a + // (possibly different) process. + void UpdateMessagePort( + int message_port_id, + WorkerMessageFilter* filter, + int routing_id); + + void OnWorkerMessageFilterClosing(WorkerMessageFilter* filter); + + // Attempts to send the queued messages for a message port. + void SendQueuedMessagesIfPossible(int message_port_id); + + private: + friend struct DefaultSingletonTraits<MessagePortService>; + + MessagePortService(); + ~MessagePortService(); + + void PostMessageTo(int message_port_id, + const string16& message, + const std::vector<int>& sent_message_port_ids); + + // Handles the details of removing a message port id. Before calling this, + // verify that the message port id exists. + void Erase(int message_port_id); + + struct MessagePort; + typedef std::map<int, MessagePort> MessagePorts; + MessagePorts message_ports_; + + // We need globally unique identifiers for each message port. + int next_message_port_id_; + + DISALLOW_COPY_AND_ASSIGN(MessagePortService); +}; + +#endif // CHROME_BROWSER_WORKER_HOST_MESSAGE_PORT_SERVICE_H_ diff --git a/chrome/browser/worker_host/worker_document_set.cc b/chrome/browser/worker_host/worker_document_set.cc index 3588bb1..0b3c634 100644 --- a/chrome/browser/worker_host/worker_document_set.cc +++ b/chrome/browser/worker_host/worker_document_set.cc @@ -4,32 +4,34 @@ #include "chrome/browser/worker_host/worker_document_set.h" +#include "base/logging.h" + WorkerDocumentSet::WorkerDocumentSet() { } -void WorkerDocumentSet::Add(IPC::Message::Sender* parent, +void WorkerDocumentSet::Add(WorkerMessageFilter* parent, unsigned long long document_id, - int renderer_id, - int render_view_route_id) { - DocumentInfo info(parent, document_id, renderer_id, render_view_route_id); + int render_process_id, + int render_view_id) { + DocumentInfo info(parent, document_id, render_process_id, render_view_id); document_set_.insert(info); } -bool WorkerDocumentSet::Contains(IPC::Message::Sender* parent, +bool WorkerDocumentSet::Contains(WorkerMessageFilter* parent, unsigned long long document_id) const { for (DocumentInfoSet::const_iterator i = document_set_.begin(); i != document_set_.end(); ++i) { - if (i->sender() == parent && i->document_id() == document_id) + if (i->filter() == parent && i->document_id() == document_id) return true; } return false; } -void WorkerDocumentSet::Remove(IPC::Message::Sender* parent, +void WorkerDocumentSet::Remove(WorkerMessageFilter* parent, unsigned long long document_id) { for (DocumentInfoSet::iterator i = document_set_.begin(); i != document_set_.end(); i++) { - if (i->sender() == parent && i->document_id() == document_id) { + if (i->filter() == parent && i->document_id() == document_id) { document_set_.erase(i); break; } @@ -38,14 +40,14 @@ void WorkerDocumentSet::Remove(IPC::Message::Sender* parent, DCHECK(!Contains(parent, document_id)); } -void WorkerDocumentSet::RemoveAll(IPC::Message::Sender* parent) { +void WorkerDocumentSet::RemoveAll(WorkerMessageFilter* parent) { for (DocumentInfoSet::iterator i = document_set_.begin(); i != document_set_.end();) { // Note this idiom is somewhat tricky - calling document_set_.erase(iter) // invalidates any iterators that point to the element being removed, so // bump the iterator beyond the item being removed before calling erase. - if (i->sender() == parent) { + if (i->filter() == parent) { DocumentInfoSet::iterator item_to_delete = i++; document_set_.erase(item_to_delete); } else { @@ -55,12 +57,13 @@ void WorkerDocumentSet::RemoveAll(IPC::Message::Sender* parent) { } WorkerDocumentSet::DocumentInfo::DocumentInfo( - IPC::Message::Sender* sender, unsigned long long document_id, - int renderer_id, int render_view_route_id) - : sender_(sender), + WorkerMessageFilter* filter, unsigned long long document_id, + int render_process_id, int render_view_id) + : filter_(filter), document_id_(document_id), - renderer_id_(renderer_id), - render_view_route_id_(render_view_route_id) { + render_process_id_(render_process_id), + render_view_id_(render_view_id) { } -WorkerDocumentSet::~WorkerDocumentSet() {} +WorkerDocumentSet::~WorkerDocumentSet() { +} diff --git a/chrome/browser/worker_host/worker_document_set.h b/chrome/browser/worker_host/worker_document_set.h index 7894fc4..49da2b6 100644 --- a/chrome/browser/worker_host/worker_document_set.h +++ b/chrome/browser/worker_host/worker_document_set.h @@ -10,7 +10,8 @@ #include "base/basictypes.h" #include "base/ref_counted.h" -#include "ipc/ipc_message.h" + +class WorkerMessageFilter; // The WorkerDocumentSet tracks all of the DOM documents associated with a // set of workers. With nested workers, multiple workers can share the same @@ -23,53 +24,53 @@ class WorkerDocumentSet : public base::RefCounted<WorkerDocumentSet> { // The information we track for each document class DocumentInfo { public: - DocumentInfo(IPC::Message::Sender* sender, unsigned long long document_id, - int renderer_id, int render_view_route_id); - IPC::Message::Sender* sender() const { return sender_; } + DocumentInfo(WorkerMessageFilter* filter, unsigned long long document_id, + int renderer_process_id, int render_view_id); + WorkerMessageFilter* filter() const { return filter_; } unsigned long long document_id() const { return document_id_; } - int renderer_id() const { return renderer_id_; } - int render_view_route_id() const { return render_view_route_id_; } + int render_process_id() const { return render_process_id_; } + int render_view_id() const { return render_view_id_; } // Define operator "<", which is used to determine uniqueness within // the set. bool operator <(const DocumentInfo& other) const { // Items are identical if the sender and document_id are identical, // otherwise create an arbitrary stable ordering based on the document - // id/sender. - if (sender() == other.sender()) { + // id/filter. + if (filter() == other.filter()) { return document_id() < other.document_id(); } else { - return reinterpret_cast<unsigned long long>(sender()) < - reinterpret_cast<unsigned long long>(other.sender()); + return reinterpret_cast<unsigned long long>(filter()) < + reinterpret_cast<unsigned long long>(other.filter()); } } private: - IPC::Message::Sender* sender_; + WorkerMessageFilter* filter_; unsigned long long document_id_; - int renderer_id_; - int render_view_route_id_; + int render_process_id_; + int render_view_id_; }; // Adds a document to a shared worker's document set. Also includes the - // associated renderer_id the document is associated with, to enable + // associated render_process_id the document is associated with, to enable // communication with the parent tab for things like http auth dialogs. - void Add(IPC::Message::Sender* parent, + void Add(WorkerMessageFilter* parent, unsigned long long document_id, - int renderer_id, - int render_view_route_id); + int render_process_id, + int render_view_id); // Checks to see if a document is in a shared worker's document set. - bool Contains(IPC::Message::Sender* parent, + bool Contains(WorkerMessageFilter* parent, unsigned long long document_id) const; // Removes a specific document from a worker's document set when that document // is detached. - void Remove(IPC::Message::Sender* parent, unsigned long long document_id); + void Remove(WorkerMessageFilter* parent, unsigned long long document_id); // Invoked when a render process exits, to remove all associated documents // from a worker's document set. - void RemoveAll(IPC::Message::Sender* parent); + void RemoveAll(WorkerMessageFilter* parent); bool IsEmpty() const { return document_set_.empty(); } diff --git a/chrome/browser/worker_host/worker_message_filter.cc b/chrome/browser/worker_host/worker_message_filter.cc new file mode 100644 index 0000000..b598202 --- /dev/null +++ b/chrome/browser/worker_host/worker_message_filter.cc @@ -0,0 +1,116 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "chrome/browser/worker_host/worker_message_filter.h" + +#include "chrome/browser/net/chrome_url_request_context.h" +#include "chrome/browser/worker_host/message_port_service.h" +#include "chrome/browser/worker_host/worker_service.h" +#include "chrome/common/net/url_request_context_getter.h" +#include "chrome/common/render_messages.h" +#include "chrome/common/render_messages_params.h" +#include "chrome/common/worker_messages.h" + +WorkerMessageFilter::WorkerMessageFilter( + int render_process_id, + URLRequestContextGetter* request_context, + ResourceDispatcherHost* resource_dispatcher_host, + CallbackWithReturnValue<int>::Type* next_routing_id) + : render_process_id_(render_process_id), + request_context_(request_context), + resource_dispatcher_host_(resource_dispatcher_host), + next_routing_id_(next_routing_id) { +} + +WorkerMessageFilter::~WorkerMessageFilter() { +} + +void WorkerMessageFilter::OnChannelClosing() { + BrowserMessageFilter::OnChannelClosing(); + + MessagePortService::GetInstance()->OnWorkerMessageFilterClosing(this); + WorkerService::GetInstance()->OnWorkerMessageFilterClosing(this); +} + +bool WorkerMessageFilter::OnMessageReceived(const IPC::Message& message, + bool* message_was_ok) { + bool handled = true; + IPC_BEGIN_MESSAGE_MAP_EX(WorkerMessageFilter, message, *message_was_ok) + // Worker messages. + // Only sent from renderer for now, until we have nested workers. + IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWorker, OnCreateWorker) + // Only sent from renderer for now, until we have nested workers. + IPC_MESSAGE_HANDLER(ViewHostMsg_LookupSharedWorker, OnLookupSharedWorker) + IPC_MESSAGE_HANDLER(ViewHostMsg_CancelCreateDedicatedWorker, + OnCancelCreateDedicatedWorker) + IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToWorker, OnForwardToWorker) + // Only sent from renderer. + IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentDetached, OnDocumentDetached) + // Message Port related messages. + IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_CreateMessagePort, + OnCreateMessagePort) + IPC_MESSAGE_FORWARD(WorkerProcessHostMsg_DestroyMessagePort, + MessagePortService::GetInstance(), + MessagePortService::Destroy) + IPC_MESSAGE_FORWARD(WorkerProcessHostMsg_Entangle, + MessagePortService::GetInstance(), + MessagePortService::Entangle) + IPC_MESSAGE_FORWARD(WorkerProcessHostMsg_PostMessage, + MessagePortService::GetInstance(), + MessagePortService::PostMessage) + IPC_MESSAGE_FORWARD(WorkerProcessHostMsg_QueueMessages, + MessagePortService::GetInstance(), + MessagePortService::QueueMessages) + IPC_MESSAGE_FORWARD(WorkerProcessHostMsg_SendQueuedMessages, + MessagePortService::GetInstance(), + MessagePortService::SendQueuedMessages) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP_EX() + + return handled; +} + +int WorkerMessageFilter::GetNextRoutingID() { + return next_routing_id_->Run(); +} + +void WorkerMessageFilter::OnCreateWorker( + const ViewHostMsg_CreateWorker_Params& params, + int* route_id) { + *route_id = params.route_id != MSG_ROUTING_NONE ? + params.route_id : next_routing_id_->Run(); + WorkerService::GetInstance()->CreateWorker( + params, *route_id, this, request_context_); +} + +void WorkerMessageFilter::OnLookupSharedWorker( + const ViewHostMsg_CreateWorker_Params& params, + bool* exists, + int* route_id, + bool* url_error) { + *route_id = next_routing_id_->Run(); + + bool off_the_record = static_cast<ChromeURLRequestContext*>( + request_context_->GetURLRequestContext())->is_off_the_record(); + WorkerService::GetInstance()->LookupSharedWorker( + params, *route_id, this, off_the_record, exists, url_error); +} + +void WorkerMessageFilter::OnCancelCreateDedicatedWorker(int route_id) { + WorkerService::GetInstance()->CancelCreateDedicatedWorker(route_id, this); +} + +void WorkerMessageFilter::OnForwardToWorker(const IPC::Message& message) { + WorkerService::GetInstance()->ForwardToWorker(message, this); +} + +void WorkerMessageFilter::OnDocumentDetached(unsigned long long document_id) { + WorkerService::GetInstance()->DocumentDetached(document_id, this); +} + +void WorkerMessageFilter::OnCreateMessagePort(int *route_id, + int* message_port_id) { + *route_id = next_routing_id_->Run(); + MessagePortService::GetInstance()->Create(*route_id, this, message_port_id); +} diff --git a/chrome/browser/worker_host/worker_message_filter.h b/chrome/browser/worker_host/worker_message_filter.h new file mode 100644 index 0000000..2e32dab --- /dev/null +++ b/chrome/browser/worker_host/worker_message_filter.h @@ -0,0 +1,62 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CHROME_BROWSER_WORKER_HOST_WORKER_MESSAGE_FILTER_H_ +#define CHROME_BROWSER_WORKER_HOST_WORKER_MESSAGE_FILTER_H_ + +#include "base/callback.h" +#include "chrome/browser/browser_message_filter.h" + +class ResourceDispatcherHost; +class URLRequestContextGetter; +struct ViewHostMsg_CreateWorker_Params; + +class WorkerMessageFilter : public BrowserMessageFilter { + public: + // |next_routing_id| is owned by this object. It can be used up until + // OnChannelClosing. + WorkerMessageFilter( + int render_process_id, + URLRequestContextGetter* request_context, + ResourceDispatcherHost* resource_dispatcher_host, + CallbackWithReturnValue<int>::Type* next_routing_id); + + // BrowserMessageFilter implementation. + virtual void OnChannelClosing(); + virtual bool OnMessageReceived(const IPC::Message& message, + bool* message_was_ok); + + int GetNextRoutingID(); + int render_process_id() const { return render_process_id_; } + ResourceDispatcherHost* resource_dispatcher_host() const { + return resource_dispatcher_host_; + } + + private: + ~WorkerMessageFilter(); + + // Message handlers. + void OnCreateWorker(const ViewHostMsg_CreateWorker_Params& params, + int* route_id); + void OnLookupSharedWorker(const ViewHostMsg_CreateWorker_Params& params, + bool* exists, + int* route_id, + bool* url_error); + void OnCancelCreateDedicatedWorker(int route_id); + void OnForwardToWorker(const IPC::Message& message); + void OnDocumentDetached(unsigned long long document_id); + void OnCreateMessagePort(int* route_id, int* message_port_id); + + int render_process_id_; + scoped_refptr<URLRequestContextGetter> request_context_; + ResourceDispatcherHost* resource_dispatcher_host_; + + // This is guaranteed to be valid until OnChannelClosing is closed, and it's + // not used after. + scoped_ptr<CallbackWithReturnValue<int>::Type> next_routing_id_; + + DISALLOW_IMPLICIT_CONSTRUCTORS(WorkerMessageFilter); +}; + +#endif // CHROME_BROWSER_WORKER_HOST_WORKER_MESSAGE_FILTER_H_ diff --git a/chrome/browser/worker_host/worker_process_host.cc b/chrome/browser/worker_host/worker_process_host.cc index 7c58421..cc3e9e2 100644 --- a/chrome/browser/worker_host/worker_process_host.cc +++ b/chrome/browser/worker_host/worker_process_host.cc @@ -19,20 +19,18 @@ #include "chrome/browser/file_system/file_system_dispatcher_host.h" #include "chrome/browser/mime_registry_message_filter.h" #include "chrome/browser/net/chrome_url_request_context.h" -#include "chrome/browser/profiles/profile.h" #include "chrome/browser/renderer_host/blob_message_filter.h" #include "chrome/browser/renderer_host/database_message_filter.h" #include "chrome/browser/renderer_host/file_utilities_message_filter.h" -#include "chrome/browser/renderer_host/render_message_filter.h" #include "chrome/browser/renderer_host/render_view_host.h" #include "chrome/browser/renderer_host/render_view_host_delegate.h" #include "chrome/browser/renderer_host/render_view_host_notification_task.h" #include "chrome/browser/renderer_host/socket_stream_dispatcher_host.h" -#include "chrome/browser/worker_host/message_port_dispatcher.h" +#include "chrome/browser/worker_host/message_port_service.h" +#include "chrome/browser/worker_host/worker_message_filter.h" #include "chrome/browser/worker_host/worker_service.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/debug_flags.h" -#include "chrome/common/notification_service.h" #include "chrome/common/render_messages.h" #include "chrome/common/render_messages_params.h" #include "chrome/common/result_codes.h" @@ -91,20 +89,12 @@ class WorkerCrashTask : public Task { WorkerProcessHost::WorkerProcessHost( ResourceDispatcherHost* resource_dispatcher_host, - ChromeURLRequestContext *request_context) + URLRequestContextGetter* request_context) : BrowserChildProcessHost(WORKER_PROCESS, resource_dispatcher_host), request_context_(request_context) { - next_route_id_callback_.reset(NewCallbackWithReturnValue( - WorkerService::GetInstance(), &WorkerService::next_worker_route_id)); } WorkerProcessHost::~WorkerProcessHost() { - // Let interested observers know we are being deleted. - NotificationService::current()->Notify( - NotificationType::WORKER_PROCESS_HOST_SHUTDOWN, - Source<WorkerProcessHost>(this), - NotificationService::NoDetails()); - // If we crashed, tell the RenderViewHosts. for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) { const WorkerDocumentSet::DocumentInfoSet& parents = @@ -113,15 +103,15 @@ WorkerProcessHost::~WorkerProcessHost() { parents.begin(); parent_iter != parents.end(); ++parent_iter) { BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, - new WorkerCrashTask(parent_iter->renderer_id(), - parent_iter->render_view_route_id())); + new WorkerCrashTask(parent_iter->render_process_id(), + parent_iter->render_view_id())); } } ChildProcessSecurityPolicy::GetInstance()->Remove(id()); } -bool WorkerProcessHost::Init() { +bool WorkerProcessHost::Init(int render_process_id) { if (!CreateChannel()) return false; @@ -195,7 +185,7 @@ bool WorkerProcessHost::Init() { // requests them. ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile( id(), - request_context_->file_system_context()-> + GetChromeURLRequestContext()->file_system_context()-> path_manager()->base_path(), base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_CREATE | @@ -210,26 +200,35 @@ bool WorkerProcessHost::Init() { base::PLATFORM_FILE_WRITE_ATTRIBUTES); } - CreateMessageFilters(); + CreateMessageFilters(render_process_id); return true; } -void WorkerProcessHost::CreateMessageFilters() { - AddFilter(new AppCacheDispatcherHost(request_context_, id())); - AddFilter(new FileSystemDispatcherHost(request_context_)); +void WorkerProcessHost::CreateMessageFilters(int render_process_id) { + ChromeURLRequestContext* chrome_url_context = GetChromeURLRequestContext(); + + worker_message_filter_= new WorkerMessageFilter( + render_process_id, + request_context_, + resource_dispatcher_host(), + NewCallbackWithReturnValue( + WorkerService::GetInstance(), &WorkerService::next_worker_route_id)); + AddFilter(worker_message_filter_); + AddFilter(new AppCacheDispatcherHost(chrome_url_context, id())); + AddFilter(new FileSystemDispatcherHost(chrome_url_context)); AddFilter(new FileUtilitiesMessageFilter(id())); AddFilter( - new BlobMessageFilter(id(), request_context_->blob_storage_context())); + new BlobMessageFilter(id(), chrome_url_context->blob_storage_context())); AddFilter(new MimeRegistryMessageFilter()); AddFilter(new DatabaseMessageFilter( - request_context_->database_tracker(), - request_context_->host_content_settings_map())); + chrome_url_context->database_tracker(), + chrome_url_context->host_content_settings_map())); SocketStreamDispatcherHost* socket_stream_dispatcher_host = new SocketStreamDispatcherHost(); socket_stream_dispatcher_host->set_url_request_context_override( - new URLRequestContextOverride(request_context_)); + new URLRequestContextOverride(chrome_url_context)); AddFilter(socket_stream_dispatcher_host); } @@ -251,22 +250,21 @@ void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) { UpdateTitle(); - // Walk all pending senders and let them know the worker has been created + // Walk all pending filters and let them know the worker has been created // (could be more than one in the case where we had to queue up worker // creation because the worker process limit was reached). - for (WorkerInstance::SenderList::const_iterator i = - instance.senders().begin(); - i != instance.senders().end(); ++i) { + for (WorkerInstance::FilterList::const_iterator i = + instance.filters().begin(); + i != instance.filters().end(); ++i) { i->first->Send(new ViewMsg_WorkerCreated(i->second)); } } bool WorkerProcessHost::FilterMessage(const IPC::Message& message, - IPC::Message::Sender* sender) { + WorkerMessageFilter* filter) { for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) { - if (!i->closed() && i->HasSender(sender, message.routing_id())) { - RelayMessage( - message, this, i->worker_route_id(), next_route_id_callback_.get()); + if (!i->closed() && i->HasFilter(filter, message.routing_id())) { + RelayMessage(message, worker_message_filter_, i->worker_route_id()); return true; } } @@ -274,42 +272,18 @@ bool WorkerProcessHost::FilterMessage(const IPC::Message& message, return false; } -// Sent to notify the browser process when a worker context invokes close(), so -// no new connections are sent to shared workers. -void WorkerProcessHost::OnWorkerContextClosed(int worker_route_id) { - for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) { - if (i->worker_route_id() == worker_route_id) { - // Set the closed flag - this will stop any further messages from - // being sent to the worker (messages can still be sent from the worker, - // for exception reporting, etc). - i->set_closed(true); - break; - } - } +void WorkerProcessHost::OnProcessLaunched() { } void WorkerProcessHost::OnMessageReceived(const IPC::Message& message) { bool msg_is_ok = true; - bool handled = - MessagePortDispatcher::GetInstance()->OnMessageReceived( - message, this, next_route_id_callback_.get(), &msg_is_ok); - - if (!handled) { - handled = true; - IPC_BEGIN_MESSAGE_MAP_EX(WorkerProcessHost, message, msg_is_ok) - IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWorker, OnCreateWorker) - IPC_MESSAGE_HANDLER(ViewHostMsg_LookupSharedWorker, OnLookupSharedWorker) - IPC_MESSAGE_HANDLER(ViewHostMsg_CancelCreateDedicatedWorker, - OnCancelCreateDedicatedWorker) - IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextClosed, - OnWorkerContextClosed); - IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToWorker, - OnForwardToWorker) - IPC_MESSAGE_HANDLER_DELAY_REPLY(WorkerProcessHostMsg_AllowDatabase, - OnAllowDatabase) - IPC_MESSAGE_UNHANDLED(handled = false) + bool handled = true; + IPC_BEGIN_MESSAGE_MAP_EX(WorkerProcessHost, message, msg_is_ok) + IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextClosed, + OnWorkerContextClosed) + IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowDatabase, OnAllowDatabase) + IPC_MESSAGE_UNHANDLED(handled = false) IPC_END_MESSAGE_MAP_EX() - } if (!msg_is_ok) { NOTREACHED(); @@ -324,10 +298,8 @@ void WorkerProcessHost::OnMessageReceived(const IPC::Message& message) { if (!i->shared()) { // Don't relay messages from shared workers (all communication is via // the message port). - WorkerInstance::SenderInfo info = i->GetSender(); - CallbackWithReturnValue<int>::Type* next_route_id = - GetNextRouteIdCallback(info.first); - RelayMessage(message, info.first, info.second, next_route_id); + WorkerInstance::FilterInfo info = i->GetFilter(); + RelayMessage(message, info.first, info.second); } if (message.type() == WorkerHostMsg_WorkerContextDestroyed::ID) { @@ -339,31 +311,53 @@ void WorkerProcessHost::OnMessageReceived(const IPC::Message& message) { } } -void WorkerProcessHost::OnProcessLaunched() { +// Sent to notify the browser process when a worker context invokes close(), so +// no new connections are sent to shared workers. +void WorkerProcessHost::OnWorkerContextClosed(int worker_route_id) { + for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) { + if (i->worker_route_id() == worker_route_id) { + // Set the closed flag - this will stop any further messages from + // being sent to the worker (messages can still be sent from the worker, + // for exception reporting, etc). + i->set_closed(true); + break; + } + } } -CallbackWithReturnValue<int>::Type* WorkerProcessHost::GetNextRouteIdCallback( - IPC::Message::Sender* sender) { - // We don't keep callbacks for senders associated with workers, so figure out - // what kind of sender this is, and cast it to the correct class to get the - // callback. - for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); - !iter.Done(); ++iter) { - WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); - if (static_cast<IPC::Message::Sender*>(worker) == sender) - return worker->next_route_id_callback_.get(); - } +void WorkerProcessHost::OnAllowDatabase(int worker_route_id, + const GURL& url, + const string16& name, + const string16& display_name, + unsigned long estimated_size, + bool* result) { + ContentSetting content_setting = GetChromeURLRequestContext()-> + host_content_settings_map()->GetContentSetting( + url, CONTENT_SETTINGS_TYPE_COOKIES, ""); - // Must be a RenderMessageFilter. - return static_cast<RenderMessageFilter*>(sender)->next_route_id_callback(); + *result = content_setting != CONTENT_SETTING_BLOCK; + + // Find the worker instance and forward the message to all attached documents. + for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) { + if (i->worker_route_id() != worker_route_id) + continue; + const WorkerDocumentSet::DocumentInfoSet& documents = + i->worker_document_set()->documents(); + for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc = + documents.begin(); doc != documents.end(); ++doc) { + CallRenderViewHostContentSettingsDelegate( + doc->render_process_id(), doc->render_view_id(), + &RenderViewHostDelegate::ContentSettings::OnWebDatabaseAccessed, + url, name, display_name, estimated_size, !*result); + } + break; + } } void WorkerProcessHost::RelayMessage( const IPC::Message& message, - IPC::Message::Sender* sender, - int route_id, - CallbackWithReturnValue<int>::Type* next_route_id) { - + WorkerMessageFilter* filter, + int route_id) { if (message.type() == WorkerMsg_PostMessage::ID) { // We want to send the receiver a routing id for the new channel, so // crack the message first. @@ -378,19 +372,19 @@ void WorkerProcessHost::RelayMessage( return; for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { - new_routing_ids[i] = next_route_id->Run(); - MessagePortDispatcher::GetInstance()->UpdateMessagePort( - sent_message_port_ids[i], sender, new_routing_ids[i], next_route_id); + new_routing_ids[i] = filter->GetNextRoutingID(); + MessagePortService::GetInstance()->UpdateMessagePort( + sent_message_port_ids[i], filter, new_routing_ids[i]); } - sender->Send(new WorkerMsg_PostMessage( + filter->Send(new WorkerMsg_PostMessage( route_id, msg, sent_message_port_ids, new_routing_ids)); // Send any queued messages to the sent message ports. We can only do this // after sending the above message, since it's the one that sets up the // message port route which the queued messages are sent to. for (size_t i = 0; i < sent_message_port_ids.size(); ++i) { - MessagePortDispatcher::GetInstance()-> + MessagePortService::GetInstance()-> SendQueuedMessagesIfPossible(sent_message_port_ids[i]); } } else if (message.type() == WorkerMsg_Connect::ID) { @@ -401,35 +395,35 @@ void WorkerProcessHost::RelayMessage( &message, &sent_message_port_id, &new_routing_id)) { return; } - new_routing_id = next_route_id->Run(); - MessagePortDispatcher::GetInstance()->UpdateMessagePort( - sent_message_port_id, sender, new_routing_id, next_route_id); + new_routing_id = filter->GetNextRoutingID(); + MessagePortService::GetInstance()->UpdateMessagePort( + sent_message_port_id, filter, new_routing_id); // Resend the message with the new routing id. - sender->Send(new WorkerMsg_Connect( + filter->Send(new WorkerMsg_Connect( route_id, sent_message_port_id, new_routing_id)); // Send any queued messages for the sent port. - MessagePortDispatcher::GetInstance()->SendQueuedMessagesIfPossible( + MessagePortService::GetInstance()->SendQueuedMessagesIfPossible( sent_message_port_id); } else { IPC::Message* new_message = new IPC::Message(message); new_message->set_routing_id(route_id); - sender->Send(new_message); + filter->Send(new_message); return; } } -void WorkerProcessHost::SenderShutdown(IPC::Message::Sender* sender) { +void WorkerProcessHost::FilterShutdown(WorkerMessageFilter* filter) { for (Instances::iterator i = instances_.begin(); i != instances_.end();) { bool shutdown = false; - i->RemoveSenders(sender); + i->RemoveFilters(filter); if (i->shared()) { - i->worker_document_set()->RemoveAll(sender); + i->worker_document_set()->RemoveAll(filter); if (i->worker_document_set()->IsEmpty()) { shutdown = true; } - } else if (i->NumSenders() == 0) { + } else if (i->NumFilters() == 0) { shutdown = true; } if (shutdown) { @@ -456,8 +450,7 @@ void WorkerProcessHost::UpdateTitle() { // Check if it's an extension-created worker, in which case we want to use // the name of the extension. - std::string extension_name = static_cast<ChromeURLRequestContext*>( - Profile::GetDefaultRequestContext()->GetURLRequestContext())-> + std::string extension_name = GetChromeURLRequestContext()-> extension_info_map()->GetNameForExtension(title); if (!extension_name.empty()) { titles.insert(extension_name); @@ -481,96 +474,19 @@ void WorkerProcessHost::UpdateTitle() { set_name(ASCIIToWide(display_title)); } -void WorkerProcessHost::OnLookupSharedWorker( - const ViewHostMsg_CreateWorker_Params& params, - bool* exists, - int* route_id, - bool* url_mismatch) { - *route_id = WorkerService::GetInstance()->next_worker_route_id(); - // TODO(atwilson): Add code to pass in the current worker's document set for - // these nested workers. Code below will not work for SharedWorkers as it - // only looks at a single parent. - DCHECK(instances_.front().worker_document_set()->documents().size() == 1); - WorkerDocumentSet::DocumentInfoSet::const_iterator first_parent = - instances_.front().worker_document_set()->documents().begin(); - *exists = WorkerService::GetInstance()->LookupSharedWorker( - params.url, params.name, instances_.front().off_the_record(), - params.document_id, first_parent->renderer_id(), - first_parent->render_view_route_id(), this, *route_id, url_mismatch); -} - -void WorkerProcessHost::OnCreateWorker( - const ViewHostMsg_CreateWorker_Params& params, int* route_id) { - DCHECK(instances_.size() == 1); // Only called when one process per worker. - // TODO(atwilson): Add code to pass in the current worker's document set for - // these nested workers. Code below will not work for SharedWorkers as it - // only looks at a single parent. - DCHECK(instances_.front().worker_document_set()->documents().size() == 1); - WorkerDocumentSet::DocumentInfoSet::const_iterator first_parent = - instances_.front().worker_document_set()->documents().begin(); - *route_id = params.route_id == MSG_ROUTING_NONE ? - WorkerService::GetInstance()->next_worker_route_id() : params.route_id; - - if (params.is_shared) - WorkerService::GetInstance()->CreateSharedWorker( - params.url, instances_.front().off_the_record(), - params.name, params.document_id, first_parent->renderer_id(), - first_parent->render_view_route_id(), this, *route_id, - params.script_resource_appcache_id, request_context_); - else - WorkerService::GetInstance()->CreateDedicatedWorker( - params.url, instances_.front().off_the_record(), - params.document_id, first_parent->renderer_id(), - first_parent->render_view_route_id(), this, *route_id, - id(), params.parent_appcache_host_id, request_context_); -} - -void WorkerProcessHost::OnCancelCreateDedicatedWorker(int route_id) { - WorkerService::GetInstance()->CancelCreateDedicatedWorker(this, route_id); -} - -void WorkerProcessHost::OnForwardToWorker(const IPC::Message& message) { - WorkerService::GetInstance()->ForwardMessage(message, this); -} - -void WorkerProcessHost::OnAllowDatabase(const GURL& url, - const string16& name, - const string16& display_name, - unsigned long estimated_size, - IPC::Message* reply_msg) { - ContentSetting content_setting = - request_context_->host_content_settings_map()->GetContentSetting( - url, CONTENT_SETTINGS_TYPE_COOKIES, ""); - - bool allowed = content_setting != CONTENT_SETTING_BLOCK; - - // Find the worker instance and forward the message to all attached documents. - for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) { - if (i->worker_route_id() != reply_msg->routing_id()) - continue; - const WorkerDocumentSet::DocumentInfoSet& documents = - i->worker_document_set()->documents(); - for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc = - documents.begin(); doc != documents.end(); ++doc) { - CallRenderViewHostContentSettingsDelegate( - doc->renderer_id(), doc->render_view_route_id(), - &RenderViewHostDelegate::ContentSettings::OnWebDatabaseAccessed, - url, name, display_name, estimated_size, !allowed); - } - break; - } - WorkerProcessHostMsg_AllowDatabase::WriteReplyParams(reply_msg, allowed); - Send(reply_msg); +ChromeURLRequestContext* WorkerProcessHost::GetChromeURLRequestContext() { + return static_cast<ChromeURLRequestContext*>( + request_context_->GetURLRequestContext()); } -void WorkerProcessHost::DocumentDetached(IPC::Message::Sender* parent, +void WorkerProcessHost::DocumentDetached(WorkerMessageFilter* filter, unsigned long long document_id) { // Walk all instances and remove the document from their document set. for (Instances::iterator i = instances_.begin(); i != instances_.end();) { if (!i->shared()) { ++i; } else { - i->worker_document_set()->Remove(parent, document_id); + i->worker_document_set()->Remove(filter, document_id); if (i->worker_document_set()->IsEmpty()) { // This worker has no more associated documents - shut it down. Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id())); @@ -591,7 +507,7 @@ WorkerProcessHost::WorkerInstance::WorkerInstance( int parent_process_id, int parent_appcache_host_id, int64 main_resource_appcache_id, - ChromeURLRequestContext* request_context) + URLRequestContextGetter* request_context) : url_(url), shared_(shared), off_the_record_(off_the_record), @@ -603,8 +519,6 @@ WorkerProcessHost::WorkerInstance::WorkerInstance( main_resource_appcache_id_(main_resource_appcache_id), request_context_(request_context), worker_document_set_(new WorkerDocumentSet()) { - DCHECK(!request_context || - (off_the_record == request_context->is_off_the_record())); } WorkerProcessHost::WorkerInstance::~WorkerInstance() { @@ -635,65 +549,65 @@ bool WorkerProcessHost::WorkerInstance::Matches( return name_ == match_name; } -void WorkerProcessHost::WorkerInstance::AddSender(IPC::Message::Sender* sender, - int sender_route_id) { - if (!HasSender(sender, sender_route_id)) { - SenderInfo info(sender, sender_route_id); - senders_.push_back(info); +void WorkerProcessHost::WorkerInstance::AddFilter(WorkerMessageFilter* filter, + int route_id) { + if (!HasFilter(filter, route_id)) { + FilterInfo info(filter, route_id); + filters_.push_back(info); } - // Only shared workers can have more than one associated sender. - DCHECK(shared_ || senders_.size() == 1); + // Only shared workers can have more than one associated filter. + DCHECK(shared_ || filters_.size() == 1); } -void WorkerProcessHost::WorkerInstance::RemoveSender( - IPC::Message::Sender* sender, int sender_route_id) { - for (SenderList::iterator i = senders_.begin(); i != senders_.end();) { - if (i->first == sender && i->second == sender_route_id) - i = senders_.erase(i); +void WorkerProcessHost::WorkerInstance::RemoveFilter( + WorkerMessageFilter* filter, int route_id) { + for (FilterList::iterator i = filters_.begin(); i != filters_.end();) { + if (i->first == filter && i->second == route_id) + i = filters_.erase(i); else ++i; } - // Should not be duplicate copies in the sender set. - DCHECK(!HasSender(sender, sender_route_id)); + // Should not be duplicate copies in the filter set. + DCHECK(!HasFilter(filter, route_id)); } -void WorkerProcessHost::WorkerInstance::RemoveSenders( - IPC::Message::Sender* sender) { - for (SenderList::iterator i = senders_.begin(); i != senders_.end();) { - if (i->first == sender) - i = senders_.erase(i); +void WorkerProcessHost::WorkerInstance::RemoveFilters( + WorkerMessageFilter* filter) { + for (FilterList::iterator i = filters_.begin(); i != filters_.end();) { + if (i->first == filter) + i = filters_.erase(i); else ++i; } } -bool WorkerProcessHost::WorkerInstance::HasSender( - IPC::Message::Sender* sender, int sender_route_id) const { - for (SenderList::const_iterator i = senders_.begin(); i != senders_.end(); +bool WorkerProcessHost::WorkerInstance::HasFilter( + WorkerMessageFilter* filter, int route_id) const { + for (FilterList::const_iterator i = filters_.begin(); i != filters_.end(); ++i) { - if (i->first == sender && i->second == sender_route_id) + if (i->first == filter && i->second == route_id) return true; } return false; } bool WorkerProcessHost::WorkerInstance::RendererIsParent( - int renderer_id, int render_view_route_id) const { + int render_process_id, int render_view_id) const { const WorkerDocumentSet::DocumentInfoSet& parents = worker_document_set()->documents(); for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter = parents.begin(); parent_iter != parents.end(); ++parent_iter) { - if (parent_iter->renderer_id() == renderer_id && - parent_iter->render_view_route_id() == render_view_route_id) { + if (parent_iter->render_process_id() == render_process_id && + parent_iter->render_view_id() == render_view_id) { return true; } } return false; } -WorkerProcessHost::WorkerInstance::SenderInfo -WorkerProcessHost::WorkerInstance::GetSender() const { - DCHECK(NumSenders() == 1); - return *senders_.begin(); +WorkerProcessHost::WorkerInstance::FilterInfo +WorkerProcessHost::WorkerInstance::GetFilter() const { + DCHECK(NumFilters() == 1); + return *filters_.begin(); } diff --git a/chrome/browser/worker_host/worker_process_host.h b/chrome/browser/worker_host/worker_process_host.h index 39aad8e..150da93 100644 --- a/chrome/browser/worker_host/worker_process_host.h +++ b/chrome/browser/worker_host/worker_process_host.h @@ -9,26 +9,19 @@ #include <list> #include "base/basictypes.h" -#include "base/callback.h" #include "base/file_path.h" #include "chrome/browser/browser_child_process_host.h" #include "chrome/browser/net/chrome_url_request_context.h" #include "chrome/browser/worker_host/worker_document_set.h" #include "googleurl/src/gurl.h" -class ChromeURLRequestContext; -class ChromeURLRequestContextGetter; -namespace webkit_database { -class DatabaseTracker; -} // namespace webkit_database - -struct ViewHostMsg_CreateWorker_Params; +class URLRequestContextGetter; // The WorkerProcessHost is the interface that represents the browser side of // the browser <-> worker communication channel. There will be one // WorkerProcessHost per worker process. Currently each worker runs in its own // process, but that may change. However, we do assume [by storing a -// ChromeURLRequestContext] that a WorkerProcessHost serves a single Profile. +// URLRequestContext] that a WorkerProcessHost serves a single Profile. class WorkerProcessHost : public BrowserChildProcessHost { public: @@ -44,24 +37,24 @@ class WorkerProcessHost : public BrowserChildProcessHost { int parent_process_id, int parent_appcache_host_id, int64 main_resource_appcache_id, - ChromeURLRequestContext* request_context); + URLRequestContextGetter* request_context); ~WorkerInstance(); // Unique identifier for a worker client. - typedef std::pair<IPC::Message::Sender*, int> SenderInfo; + typedef std::pair<WorkerMessageFilter*, int> FilterInfo; - // APIs to manage the sender list for a given instance. - void AddSender(IPC::Message::Sender* sender, int sender_route_id); - void RemoveSender(IPC::Message::Sender* sender, int sender_route_id); - void RemoveSenders(IPC::Message::Sender* sender); - bool HasSender(IPC::Message::Sender* sender, int sender_route_id) const; - bool RendererIsParent(int renderer_id, int render_view_route_id) const; - int NumSenders() const { return senders_.size(); } - // Returns the single sender (must only be one). - SenderInfo GetSender() const; + // APIs to manage the filter list for a given instance. + void AddFilter(WorkerMessageFilter* filter, int route_id); + void RemoveFilter(WorkerMessageFilter* filter, int route_id); + void RemoveFilters(WorkerMessageFilter* filter); + bool HasFilter(WorkerMessageFilter* filter, int route_id) const; + bool RendererIsParent(int render_process_id, int render_view_id) const; + int NumFilters() const { return filters_.size(); } + // Returns the single filter (must only be one). + FilterInfo GetFilter() const; - typedef std::list<SenderInfo> SenderList; - const SenderList& senders() const { return senders_; } + typedef std::list<FilterInfo> FilterList; + const FilterList& filters() const { return filters_; } // Checks if this WorkerInstance matches the passed url/name params // (per the comparison algorithm in the WebWorkers spec). This API only @@ -92,12 +85,12 @@ class WorkerProcessHost : public BrowserChildProcessHost { WorkerDocumentSet* worker_document_set() const { return worker_document_set_; } - ChromeURLRequestContext* request_context() const { + URLRequestContextGetter* request_context() const { return request_context_; } private: - // Set of all senders (clients) associated with this worker. + // Set of all filters (clients) associated with this worker. GURL url_; bool shared_; bool off_the_record_; @@ -107,34 +100,36 @@ class WorkerProcessHost : public BrowserChildProcessHost { int parent_process_id_; int parent_appcache_host_id_; int64 main_resource_appcache_id_; - scoped_refptr<ChromeURLRequestContext> request_context_; - SenderList senders_; + scoped_refptr<URLRequestContextGetter> request_context_; + FilterList filters_; scoped_refptr<WorkerDocumentSet> worker_document_set_; }; WorkerProcessHost( ResourceDispatcherHost* resource_dispatcher_host, - ChromeURLRequestContext* request_context); + URLRequestContextGetter* request_context); ~WorkerProcessHost(); // Starts the process. Returns true iff it succeeded. - bool Init(); + // |render_process_id| is the renderer process responsible for starting this + // worker. + bool Init(int render_process_id); // Creates a worker object in the process. void CreateWorker(const WorkerInstance& instance); // Returns true iff the given message from a renderer process was forwarded to // the worker. - bool FilterMessage(const IPC::Message& message, IPC::Message::Sender* sender); + bool FilterMessage(const IPC::Message& message, WorkerMessageFilter* filter); - void SenderShutdown(IPC::Message::Sender* sender); + void FilterShutdown(WorkerMessageFilter* filter); // Shuts down any shared workers that are no longer referenced by active // documents. - void DocumentDetached(IPC::Message::Sender* sender, + void DocumentDetached(WorkerMessageFilter* filter, unsigned long long document_id); - ChromeURLRequestContext* request_context() const { + URLRequestContextGetter* request_context() const { return request_context_; } @@ -146,61 +141,45 @@ class WorkerProcessHost : public BrowserChildProcessHost { Instances& mutable_instances() { return instances_; } private: - // IPC::Channel::Listener implementation: - // Called when a message arrives from the worker process. - virtual void OnMessageReceived(const IPC::Message& message); - - // Creates and adds the message filters. - void CreateMessageFilters(); - // Called when the process has been launched successfully. virtual void OnProcessLaunched(); - // Called when the app invokes close() from within worker context. - void OnWorkerContextClosed(int worker_route_id); + // Creates and adds the message filters. + void CreateMessageFilters(int render_process_id); - // Called if a worker tries to connect to a shared worker. - void OnLookupSharedWorker(const ViewHostMsg_CreateWorker_Params& params, - bool* exists, - int* route_id, - bool* url_error); + // IPC::Channel::Listener implementation: + // Called when a message arrives from the worker process. + virtual void OnMessageReceived(const IPC::Message& message); - // Given a Sender, returns the callback that generates a new routing id. - static CallbackWithReturnValue<int>::Type* GetNextRouteIdCallback( - IPC::Message::Sender* sender); + void OnWorkerContextClosed(int worker_route_id); + void OnAllowDatabase(int worker_route_id, + const GURL& url, + const string16& name, + const string16& display_name, + unsigned long estimated_size, + bool* result); // Relays a message to the given endpoint. Takes care of parsing the message // if it contains a message port and sending it a valid route id. static void RelayMessage(const IPC::Message& message, - IPC::Message::Sender* sender, - int route_id, - CallbackWithReturnValue<int>::Type* next_route_id); + WorkerMessageFilter* filter, + int route_id); virtual bool CanShutdown(); // Updates the title shown in the task manager. void UpdateTitle(); - void OnCreateWorker(const ViewHostMsg_CreateWorker_Params& params, - int* route_id); - void OnCancelCreateDedicatedWorker(int route_id); - void OnForwardToWorker(const IPC::Message& message); - - // Checks the content settings whether access to web databases is enabled and - // relays the WebDatabaseAccessed message to all documents attached to a - // worker. - void OnAllowDatabase(const GURL& url, - const string16& name, - const string16& display_name, - unsigned long estimated_size, - IPC::Message* reply_msg); + ChromeURLRequestContext* GetChromeURLRequestContext(); Instances instances_; - scoped_refptr<ChromeURLRequestContext> request_context_; + scoped_refptr<URLRequestContextGetter> request_context_; - // A callback to create a routing id for the associated worker process. - scoped_ptr<CallbackWithReturnValue<int>::Type> next_route_id_callback_; + // A reference to the filter associated with this worker process. We need to + // keep this around since we'll use it when forward messages to the worker + // process. + scoped_refptr<WorkerMessageFilter> worker_message_filter_; DISALLOW_COPY_AND_ASSIGN(WorkerProcessHost); }; diff --git a/chrome/browser/worker_host/worker_service.cc b/chrome/browser/worker_host/worker_service.cc index e623db1..cea298d 100644 --- a/chrome/browser/worker_host/worker_service.cc +++ b/chrome/browser/worker_host/worker_service.cc @@ -11,13 +11,11 @@ #include "base/sys_info.h" #include "base/thread.h" #include "chrome/browser/content_settings/host_content_settings_map.h" -#include "chrome/browser/plugin_service.h" -#include "chrome/browser/renderer_host/render_message_filter.h" -#include "chrome/browser/renderer_host/render_process_host.h" +#include "chrome/browser/worker_host/worker_message_filter.h" #include "chrome/browser/worker_host/worker_process_host.h" #include "chrome/common/chrome_switches.h" -#include "chrome/common/notification_service.h" #include "chrome/common/render_messages.h" +#include "chrome/common/render_messages_params.h" #include "chrome/common/worker_messages.h" #include "net/base/registry_controlled_domain.h" @@ -29,97 +27,205 @@ WorkerService* WorkerService::GetInstance() { return Singleton<WorkerService>::get(); } -WorkerService::WorkerService() - : next_worker_route_id_(0), - resource_dispatcher_host_(NULL) { - // Receive a notification if a message filter or WorkerProcessHost is deleted. - registrar_.Add(this, NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN, - NotificationService::AllSources()); - - registrar_.Add(this, NotificationType::WORKER_PROCESS_HOST_SHUTDOWN, - NotificationService::AllSources()); -} - -void WorkerService::Initialize(ResourceDispatcherHost* rdh) { - resource_dispatcher_host_ = rdh; +WorkerService::WorkerService() : next_worker_route_id_(0) { } WorkerService::~WorkerService() { } -bool WorkerService::CreateDedicatedWorker( - const GURL& url, - bool is_off_the_record, - unsigned long long document_id, - int renderer_pid, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - int parent_process_id, - int parent_appcache_host_id, - ChromeURLRequestContext* request_context) { - return CreateWorker(url, false, is_off_the_record, string16(), - document_id, renderer_pid, render_view_route_id, - sender, sender_route_id, - parent_process_id, parent_appcache_host_id, 0, - request_context); -} +void WorkerService::OnWorkerMessageFilterClosing(WorkerMessageFilter* filter) { + for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); + !iter.Done(); ++iter) { + WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); + worker->FilterShutdown(filter); + } + + // See if that process had any queued workers. + for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin(); + i != queued_workers_.end();) { + i->RemoveFilters(filter); + if (i->NumFilters() == 0) { + i = queued_workers_.erase(i); + } else { + ++i; + } + } -bool WorkerService::CreateSharedWorker( - const GURL& url, - bool is_off_the_record, - const string16& name, - unsigned long long document_id, - int renderer_pid, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - int64 main_resource_appcache_id, - ChromeURLRequestContext* request_context) { - return CreateWorker(url, true, is_off_the_record, name, - document_id, renderer_pid, render_view_route_id, - sender, sender_route_id, - 0, 0, main_resource_appcache_id, - request_context); + // Also, see if that process had any pending shared workers. + for (WorkerProcessHost::Instances::iterator iter = + pending_shared_workers_.begin(); + iter != pending_shared_workers_.end(); ) { + iter->worker_document_set()->RemoveAll(filter); + if (iter->worker_document_set()->IsEmpty()) { + iter = pending_shared_workers_.erase(iter); + } else { + ++iter; + } + } + + // Either a worker proceess has shut down, in which case we can start one of + // the queued workers, or a renderer has shut down, in which case it doesn't + // affect anything. We call this function in both scenarios because then we + // don't have to keep track which filters are from worker processes. + TryStartingQueuedWorker(); } -bool WorkerService::CreateWorker( - const GURL& url, - bool is_shared, - bool off_the_record, - const string16& name, - unsigned long long document_id, - int renderer_id, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - int parent_process_id, - int parent_appcache_host_id, - int64 main_resource_appcache_id, - ChromeURLRequestContext* request_context) { +void WorkerService::CreateWorker(const ViewHostMsg_CreateWorker_Params& params, + int route_id, + WorkerMessageFilter* filter, + URLRequestContextGetter* request_context) { + + ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>( + request_context->GetURLRequestContext()); + // Generate a unique route id for the browser-worker communication that's // unique among all worker processes. That way when the worker process sends // a wrapped IPC message through us, we know which WorkerProcessHost to give // it to. - WorkerProcessHost::WorkerInstance instance(url, - is_shared, - off_the_record, - name, - next_worker_route_id(), - parent_process_id, - parent_appcache_host_id, - main_resource_appcache_id, - request_context); - instance.AddSender(sender, sender_route_id); + WorkerProcessHost::WorkerInstance instance( + params.url, + params.is_shared, + context->is_off_the_record(), + params.name, + next_worker_route_id(), + params.is_shared ? 0 : filter->render_process_id(), + params.is_shared ? 0 : params.parent_appcache_host_id, + params.is_shared ? params.script_resource_appcache_id : 0, + request_context); + instance.AddFilter(filter, route_id); instance.worker_document_set()->Add( - sender, document_id, renderer_id, render_view_route_id); + filter, params.document_id, filter->render_process_id(), + params.render_view_route_id); + + CreateWorkerFromInstance(instance); +} + +void WorkerService::LookupSharedWorker( + const ViewHostMsg_CreateWorker_Params& params, + int route_id, + WorkerMessageFilter* filter, + bool off_the_record, + bool* exists, + bool* url_mismatch) { + + *exists = true; + WorkerProcessHost::WorkerInstance* instance = FindSharedWorkerInstance( + params.url, params.name, off_the_record); + + if (!instance) { + // If no worker instance currently exists, we need to create a pending + // instance - this is to make sure that any subsequent lookups passing a + // mismatched URL get the appropriate url_mismatch error at lookup time. + // Having named shared workers was a Really Bad Idea due to details like + // this. + instance = CreatePendingInstance(params.url, params.name, off_the_record); + *exists = false; + } + + // Make sure the passed-in instance matches the URL - if not, return an + // error. + if (params.url != instance->url()) { + *url_mismatch = true; + *exists = false; + } else { + *url_mismatch = false; + // Add our route ID to the existing instance so we can send messages to it. + instance->AddFilter(filter, route_id); + + // Add the passed filter/document_id to the worker instance. + // TODO(atwilson): This won't work if the message is from a worker process. + // We don't support that yet though (this message is only sent from + // renderers) but when we do, we'll need to add code to pass in the current + // worker's document set for nested workers. + instance->worker_document_set()->Add( + filter, params.document_id, filter->render_process_id(), + params.render_view_route_id); + } +} + +void WorkerService::CancelCreateDedicatedWorker( + int route_id, + WorkerMessageFilter* filter) { + for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin(); + i != queued_workers_.end(); ++i) { + if (i->HasFilter(filter, route_id)) { + DCHECK(!i->shared()); + queued_workers_.erase(i); + return; + } + } + + // There could be a race condition where the WebWorkerProxy told us to cancel + // the worker right as we sent it a message say it's been created. Look at + // the running workers. + for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); + !iter.Done(); ++iter) { + WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); + for (WorkerProcessHost::Instances::const_iterator instance = + worker->instances().begin(); + instance != worker->instances().end(); ++instance) { + if (instance->HasFilter(filter, route_id)) { + // Fake a worker destroyed message so that WorkerProcessHost cleans up + // properly. + WorkerHostMsg_WorkerContextDestroyed message(route_id); + ForwardToWorker(message, filter); + return; + } + } + } + + DCHECK(false) << "Couldn't find worker to cancel"; +} + +void WorkerService::ForwardToWorker(const IPC::Message& message, + WorkerMessageFilter* filter) { + for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); + !iter.Done(); ++iter) { + WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); + if (worker->FilterMessage(message, filter)) + return; + } + + // TODO(jabdelmalek): tell filter that callee is gone +} + +void WorkerService::DocumentDetached(unsigned long long document_id, + WorkerMessageFilter* filter) { + // Any associated shared workers can be shut down. + for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); + !iter.Done(); ++iter) { + WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); + worker->DocumentDetached(filter, document_id); + } - return CreateWorkerFromInstance(instance); + // Remove any queued shared workers for this document. + for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin(); + iter != queued_workers_.end();) { + if (iter->shared()) { + iter->worker_document_set()->Remove(filter, document_id); + if (iter->worker_document_set()->IsEmpty()) { + iter = queued_workers_.erase(iter); + continue; + } + } + ++iter; + } + + // Remove the document from any pending shared workers. + for (WorkerProcessHost::Instances::iterator iter = + pending_shared_workers_.begin(); + iter != pending_shared_workers_.end(); ) { + iter->worker_document_set()->Remove(filter, document_id); + if (iter->worker_document_set()->IsEmpty()) { + iter = pending_shared_workers_.erase(iter); + } else { + ++iter; + } + } } bool WorkerService::CreateWorkerFromInstance( WorkerProcessHost::WorkerInstance instance) { - // TODO(michaeln): We need to ensure that a process is working // on behalf of a single profile. The process sharing logic below // does not ensure that. Consider making WorkerService a per profile @@ -145,17 +251,17 @@ bool WorkerService::CreateWorkerFromInstance( WorkerProcessHost::WorkerInstance* existing_instance = FindSharedWorkerInstance( instance.url(), instance.name(), instance.off_the_record()); - WorkerProcessHost::WorkerInstance::SenderInfo sender_info = - instance.GetSender(); + WorkerProcessHost::WorkerInstance::FilterInfo filter_info = + instance.GetFilter(); // If this worker is already running, no need to create a new copy. Just // inform the caller that the worker has been created. if (existing_instance) { - // Walk the worker's sender list to see if this client is listed. If not, + // Walk the worker's filter list to see if this client is listed. If not, // then it means that the worker started by the client already exited so // we should not attach to this new one (http://crbug.com/29243). - if (!existing_instance->HasSender(sender_info.first, sender_info.second)) + if (!existing_instance->HasFilter(filter_info.first, filter_info.second)) return false; - sender_info.first->Send(new ViewMsg_WorkerCreated(sender_info.second)); + filter_info.first->Send(new ViewMsg_WorkerCreated(filter_info.second)); return true; } @@ -163,38 +269,38 @@ bool WorkerService::CreateWorkerFromInstance( WorkerProcessHost::WorkerInstance* pending = FindPendingInstance( instance.url(), instance.name(), instance.off_the_record()); // If there's no instance *and* no pending instance (or there is a pending - // instance but it does not contain our sender info), then it means the + // instance but it does not contain our filter info), then it means the // worker started up and exited already. Log a warning because this should // be a very rare occurrence and is probably a bug, but it *can* happen so // handle it gracefully. if (!pending || - !pending->HasSender(sender_info.first, sender_info.second)) { + !pending->HasFilter(filter_info.first, filter_info.second)) { DLOG(WARNING) << "Pending worker already exited"; return false; } - // Assign the accumulated document set and sender list for this pending + // Assign the accumulated document set and filter list for this pending // worker to the new instance. DCHECK(!pending->worker_document_set()->IsEmpty()); instance.ShareDocumentSet(*pending); - for (WorkerProcessHost::WorkerInstance::SenderList::const_iterator i = - pending->senders().begin(); - i != pending->senders().end(); ++i) { - instance.AddSender(i->first, i->second); + for (WorkerProcessHost::WorkerInstance::FilterList::const_iterator i = + pending->filters().begin(); + i != pending->filters().end(); ++i) { + instance.AddFilter(i->first, i->second); } RemovePendingInstances( instance.url(), instance.name(), instance.off_the_record()); - // Remove any queued instances of this worker and copy over the sender to + // Remove any queued instances of this worker and copy over the filter to // this instance. for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin(); iter != queued_workers_.end();) { if (iter->Matches(instance.url(), instance.name(), instance.off_the_record())) { - DCHECK(iter->NumSenders() == 1); - WorkerProcessHost::WorkerInstance::SenderInfo sender_info = - iter->GetSender(); - instance.AddSender(sender_info.first, sender_info.second); + DCHECK(iter->NumFilters() == 1); + WorkerProcessHost::WorkerInstance::FilterInfo filter_info = + iter->GetFilter(); + instance.AddFilter(filter_info.first, filter_info.second); iter = queued_workers_.erase(iter); } else { ++iter; @@ -203,9 +309,15 @@ bool WorkerService::CreateWorkerFromInstance( } if (!worker) { - worker = new WorkerProcessHost(resource_dispatcher_host_, - instance.request_context()); - if (!worker->Init()) { + WorkerMessageFilter* first_filter = instance.filters().begin()->first; + worker = new WorkerProcessHost( + first_filter->resource_dispatcher_host(), + instance.request_context()); + // TODO(atwilson): This won't work if the message is from a worker process. + // We don't support that yet though (this message is only sent from + // renderers) but when we do, we'll need to add code to pass in the current + // worker's document set for nested workers. + if (!worker->Init(first_filter->render_process_id())) { delete worker; return false; } @@ -219,127 +331,6 @@ bool WorkerService::CreateWorkerFromInstance( return true; } -bool WorkerService::LookupSharedWorker( - const GURL &url, - const string16& name, - bool off_the_record, - unsigned long long document_id, - int renderer_id, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - bool* url_mismatch) { - bool found_instance = true; - WorkerProcessHost::WorkerInstance* instance = - FindSharedWorkerInstance(url, name, off_the_record); - - if (!instance) { - // If no worker instance currently exists, we need to create a pending - // instance - this is to make sure that any subsequent lookups passing a - // mismatched URL get the appropriate url_mismatch error at lookup time. - // Having named shared workers was a Really Bad Idea due to details like - // this. - instance = CreatePendingInstance(url, name, off_the_record); - found_instance = false; - } - - // Make sure the passed-in instance matches the URL - if not, return an - // error. - if (url != instance->url()) { - *url_mismatch = true; - return false; - } else { - *url_mismatch = false; - } - - // Add our route ID to the existing instance so we can send messages to it. - instance->AddSender(sender, sender_route_id); - - // Add the passed sender/document_id to the worker instance. - instance->worker_document_set()->Add( - sender, document_id, renderer_id, render_view_route_id); - return found_instance; -} - -void WorkerService::DocumentDetached(IPC::Message::Sender* sender, - unsigned long long document_id) { - for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); - !iter.Done(); ++iter) { - WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); - worker->DocumentDetached(sender, document_id); - } - - // Remove any queued shared workers for this document. - for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin(); - iter != queued_workers_.end();) { - if (iter->shared()) { - iter->worker_document_set()->Remove(sender, document_id); - if (iter->worker_document_set()->IsEmpty()) { - iter = queued_workers_.erase(iter); - continue; - } - } - ++iter; - } - - // Remove the document from any pending shared workers. - for (WorkerProcessHost::Instances::iterator iter = - pending_shared_workers_.begin(); - iter != pending_shared_workers_.end(); ) { - iter->worker_document_set()->Remove(sender, document_id); - if (iter->worker_document_set()->IsEmpty()) { - iter = pending_shared_workers_.erase(iter); - } else { - ++iter; - } - } -} - -void WorkerService::CancelCreateDedicatedWorker(IPC::Message::Sender* sender, - int sender_route_id) { - for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin(); - i != queued_workers_.end(); ++i) { - if (i->HasSender(sender, sender_route_id)) { - DCHECK(!i->shared()); - queued_workers_.erase(i); - return; - } - } - - // There could be a race condition where the WebWorkerProxy told us to cancel - // the worker right as we sent it a message say it's been created. Look at - // the running workers. - for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); - !iter.Done(); ++iter) { - WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); - for (WorkerProcessHost::Instances::const_iterator instance = - worker->instances().begin(); - instance != worker->instances().end(); ++instance) { - if (instance->HasSender(sender, sender_route_id)) { - // Fake a worker destroyed message so that WorkerProcessHost cleans up - // properly. - WorkerHostMsg_WorkerContextDestroyed msg(sender_route_id); - ForwardMessage(msg, sender); - return; - } - } - } - - DCHECK(false) << "Couldn't find worker to cancel"; -} - -void WorkerService::ForwardMessage(const IPC::Message& message, - IPC::Message::Sender* sender) { - for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); - !iter.Done(); ++iter) { - WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); - if (worker->FilterMessage(message, sender)) - return; - } - - // TODO(jabdelmalek): tell sender that callee is gone -} - WorkerProcessHost* WorkerService::GetProcessForDomain(const GURL& url) { int num_processes = 0; std::string domain = @@ -398,8 +389,8 @@ bool WorkerService::CanCreateWorkerProcess( parents.begin(); parent_iter != parents.end(); ++parent_iter) { bool hit_total_worker_limit = false; - if (TabCanCreateWorkerProcess(parent_iter->renderer_id(), - parent_iter->render_view_route_id(), + if (TabCanCreateWorkerProcess(parent_iter->render_process_id(), + parent_iter->render_view_id(), &hit_total_worker_limit)) { return true; } @@ -413,8 +404,8 @@ bool WorkerService::CanCreateWorkerProcess( return false; } -bool WorkerService::TabCanCreateWorkerProcess(int renderer_id, - int render_view_route_id, +bool WorkerService::TabCanCreateWorkerProcess(int render_process_id, + int render_view_id, bool* hit_total_worker_limit) { int total_workers = 0; int workers_per_tab = 0; @@ -430,7 +421,7 @@ bool WorkerService::TabCanCreateWorkerProcess(int renderer_id, *hit_total_worker_limit = true; return false; } - if (cur_instance->RendererIsParent(renderer_id, render_view_route_id)) { + if (cur_instance->RendererIsParent(render_process_id, render_view_id)) { workers_per_tab++; if (workers_per_tab >= kMaxWorkersPerTabWhenSeparate) return false; @@ -441,53 +432,7 @@ bool WorkerService::TabCanCreateWorkerProcess(int renderer_id, return true; } -void WorkerService::Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details) { - if (type.value == NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN) { - RenderMessageFilter* sender = Source<RenderMessageFilter>(source).ptr(); - SenderShutdown(sender); - } else if (type.value == NotificationType::WORKER_PROCESS_HOST_SHUTDOWN) { - WorkerProcessHost* sender = Source<WorkerProcessHost>(source).ptr(); - SenderShutdown(sender); - WorkerProcessDestroyed(sender); - } else { - NOTREACHED(); - } -} - -void WorkerService::SenderShutdown(IPC::Message::Sender* sender) { - for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); - !iter.Done(); ++iter) { - WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); - worker->SenderShutdown(sender); - } - - // See if that render process had any queued workers. - for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin(); - i != queued_workers_.end();) { - i->RemoveSenders(sender); - if (i->NumSenders() == 0) { - i = queued_workers_.erase(i); - } else { - ++i; - } - } - - // Also, see if that render process had any pending shared workers. - for (WorkerProcessHost::Instances::iterator iter = - pending_shared_workers_.begin(); - iter != pending_shared_workers_.end(); ) { - iter->worker_document_set()->RemoveAll(sender); - if (iter->worker_document_set()->IsEmpty()) { - iter = pending_shared_workers_.erase(iter); - } else { - ++iter; - } - } -} - -void WorkerService::WorkerProcessDestroyed(WorkerProcessHost* process) { +void WorkerService::TryStartingQueuedWorker() { if (queued_workers_.empty()) return; @@ -510,6 +455,30 @@ void WorkerService::WorkerProcessDestroyed(WorkerProcessHost* process) { } } +bool WorkerService::GetRendererForWorker(int worker_process_id, + int* render_process_id, + int* render_view_id) const { + for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); + !iter.Done(); ++iter) { + if (iter->id() != worker_process_id) + continue; + + // This code assumes one worker per process, see function comment in header! + WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter); + WorkerProcessHost::Instances::const_iterator first_instance = + worker->instances().begin(); + if (first_instance == worker->instances().end()) + return false; + + WorkerDocumentSet::DocumentInfoSet::const_iterator info = + first_instance->worker_document_set()->documents().begin(); + *render_process_id = info->render_process_id(); + *render_view_id = info->render_view_id(); + return true; + } + return false; +} + const WorkerProcessHost::WorkerInstance* WorkerService::FindWorkerInstance( int worker_process_id) { for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS); diff --git a/chrome/browser/worker_host/worker_service.h b/chrome/browser/worker_host/worker_service.h index 994d11f..7c39d57 100644 --- a/chrome/browser/worker_host/worker_service.h +++ b/chrome/browser/worker_host/worker_service.h @@ -11,83 +11,50 @@ #include "base/basictypes.h" #include "base/singleton.h" #include "chrome/browser/worker_host/worker_process_host.h" -#include "chrome/common/notification_registrar.h" #include "googleurl/src/gurl.h" #include "ipc/ipc_message.h" -class ChromeURLRequestContext; -class ResourceDispatcherHost; +class URLRequestContextGetter; +struct ViewHostMsg_CreateWorker_Params; -class WorkerService : public NotificationObserver { +// A singelton for managing HTML5 web workers. +class WorkerService { public: // Returns the WorkerService singleton. static WorkerService* GetInstance(); - // Initialize the WorkerService. OK to be called multiple times. - void Initialize(ResourceDispatcherHost* rdh); - - // Creates a decidated worker. Returns true on success. - bool CreateDedicatedWorker(const GURL &url, - bool is_off_the_record, - unsigned long long document_id, - int renderer_pid, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - int parent_process_id, - int parent_appcache_host_id, - ChromeURLRequestContext* request_context); - - // Creates a shared worker. Returns true on success. - bool CreateSharedWorker(const GURL &url, - bool is_off_the_record, - const string16& name, - unsigned long long document_id, - int renderer_pid, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - int64 main_resource_appcache_id, - ChromeURLRequestContext* request_context); - - // Validates the passed URL and checks for the existence of matching shared - // worker. Returns true if the url was found, and sets the url_mismatch out - // param to true/false depending on whether there's a url mismatch with an - // existing shared worker with the same name. - bool LookupSharedWorker(const GURL &url, - const string16& name, + // These methods correspond to worker related IPCs. + void CreateWorker(const ViewHostMsg_CreateWorker_Params& params, + int route_id, + WorkerMessageFilter* filter, + URLRequestContextGetter* request_context); + void LookupSharedWorker(const ViewHostMsg_CreateWorker_Params& params, + int route_id, + WorkerMessageFilter* filter, bool off_the_record, - unsigned long long document_id, - int renderer_pid, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - bool* url_mismatch); - - // Notification from the renderer that a given document has detached, so any - // associated shared workers can be shut down. - void DocumentDetached(IPC::Message::Sender* sender, - unsigned long long document_id); - - // Cancel creation of a dedicated worker that hasn't started yet. - void CancelCreateDedicatedWorker(IPC::Message::Sender* sender, - int sender_route_id); - - // Called by the worker creator when a message arrives that should be - // forwarded to the worker process. - void ForwardMessage(const IPC::Message& message, - IPC::Message::Sender* sender); + bool* exists, + bool* url_error); + void CancelCreateDedicatedWorker(int route_id, WorkerMessageFilter* filter); + void ForwardToWorker(const IPC::Message& message, + WorkerMessageFilter* filter); + void DocumentDetached(unsigned long long document_id, + WorkerMessageFilter* filter); + + void OnWorkerMessageFilterClosing(WorkerMessageFilter* filter); int next_worker_route_id() { return ++next_worker_route_id_; } + // Given a worker's process id, return the IDs of the renderer process and + // render view that created it. For shared workers, this returns the first + // parent. // TODO(dimich): This code assumes there is 1 worker per worker process, which // is how it is today until V8 can run in separate threads. + bool GetRendererForWorker(int worker_process_id, + int* render_process_id, + int* render_view_id) const; const WorkerProcessHost::WorkerInstance* FindWorkerInstance( int worker_process_id); - WorkerProcessHost::WorkerInstance* FindSharedWorkerInstance( - const GURL& url, const string16& name, bool off_the_record); - // Used when multiple workers can run in the same process. static const int kMaxWorkerProcessesWhenSharing; @@ -101,20 +68,6 @@ class WorkerService : public NotificationObserver { WorkerService(); ~WorkerService(); - bool CreateWorker(const GURL &url, - bool is_shared, - bool is_off_the_record, - const string16& name, - unsigned long long document_id, - int renderer_pid, - int render_view_route_id, - IPC::Message::Sender* sender, - int sender_route_id, - int parent_process_id, - int parent_appcache_host_id, - int64 main_resource_appcache_id, - ChromeURLRequestContext* request_context); - // Given a WorkerInstance, create an associated worker process. bool CreateWorkerFromInstance(WorkerProcessHost::WorkerInstance instance); @@ -139,18 +92,10 @@ class WorkerService : public NotificationObserver { // worker process based on the process limit when we're using a strategy of // one worker per process. bool TabCanCreateWorkerProcess( - int renderer_id, int render_view_route_id, bool* hit_total_worker_limit); + int render_process_id, int render_route_id, bool* hit_total_worker_limit); - // NotificationObserver interface. - virtual void Observe(NotificationType type, - const NotificationSource& source, - const NotificationDetails& details); - - // Notifies us that a process that's talking to a worker has shut down. - void SenderShutdown(IPC::Message::Sender* sender); - - // Notifies us that a worker process has closed. - void WorkerProcessDestroyed(WorkerProcessHost* process); + // Tries to see if any of the queued workers can be created. + void TryStartingQueuedWorker(); // APIs for manipulating our set of pending shared worker instances. WorkerProcessHost::WorkerInstance* CreatePendingInstance( @@ -160,9 +105,11 @@ class WorkerService : public NotificationObserver { void RemovePendingInstances( const GURL& url, const string16& name, bool off_the_record); + WorkerProcessHost::WorkerInstance* FindSharedWorkerInstance( + const GURL& url, const string16& name, bool off_the_record); + NotificationRegistrar registrar_; int next_worker_route_id_; - ResourceDispatcherHost* resource_dispatcher_host_; WorkerProcessHost::Instances queued_workers_; diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi index b5fabe1..cfe644b 100644 --- a/chrome/chrome_browser.gypi +++ b/chrome/chrome_browser.gypi @@ -3489,10 +3489,12 @@ 'browser/web_applications/web_app.h', 'browser/web_resource/web_resource_service.h', 'browser/web_resource/web_resource_service.cc', - 'browser/worker_host/message_port_dispatcher.cc', - 'browser/worker_host/message_port_dispatcher.h', + 'browser/worker_host/message_port_service.cc', + 'browser/worker_host/message_port_service.h', 'browser/worker_host/worker_document_set.cc', 'browser/worker_host/worker_document_set.h', + 'browser/worker_host/worker_message_filter.cc', + 'browser/worker_host/worker_message_filter.h', 'browser/worker_host/worker_process_host.cc', 'browser/worker_host/worker_process_host.h', 'browser/worker_host/worker_service.cc', diff --git a/chrome/common/notification_type.h b/chrome/common/notification_type.h index 8564063..d27f2f8 100644 --- a/chrome/common/notification_type.h +++ b/chrome/common/notification_type.h @@ -183,16 +183,6 @@ class NotificationType { // change. There are no details. SSL_INTERNAL_STATE_CHANGED, - // Lets resource handlers and other interested observers know when the - // message filter is being deleted and can no longer be used. This will - // also get sent if the renderer crashes (and in that case, it'll be sent - // twice). - RESOURCE_MESSAGE_FILTER_SHUTDOWN, - - // Lets interested observers know when a WorkerProcessHost is being deleted - // and can no longer be used. - WORKER_PROCESS_HOST_SHUTDOWN, - // Views ------------------------------------------------------------------- // Notification that a view was removed from a view hierarchy. The source diff --git a/chrome/common/worker_messages_internal.h b/chrome/common/worker_messages_internal.h index d1ef439..e661f67 100644 --- a/chrome/common/worker_messages_internal.h +++ b/chrome/common/worker_messages_internal.h @@ -76,12 +76,13 @@ IPC_MESSAGE_CONTROL2(WorkerProcessHostMsg_SendQueuedMessages, // Sent by the worker process to check whether access to web databases is // granted by content settings. -IPC_SYNC_MESSAGE_ROUTED4_1(WorkerProcessHostMsg_AllowDatabase, - GURL /* origin url */, - string16 /* database name */, - string16 /* database display name */, - unsigned long /* estimated size */, - bool /* result */) +IPC_SYNC_MESSAGE_CONTROL5_1(WorkerProcessHostMsg_AllowDatabase, + int /* worker_route_id */, + GURL /* origin url */, + string16 /* database name */, + string16 /* database display name */, + unsigned long /* estimated size */, + bool /* result */) //----------------------------------------------------------------------------- // Worker messages diff --git a/chrome_frame/chrome_frame_automation.cc b/chrome_frame/chrome_frame_automation.cc index b25b89d..8fb4d48 100644 --- a/chrome_frame/chrome_frame_automation.cc +++ b/chrome_frame/chrome_frame_automation.cc @@ -1103,7 +1103,7 @@ bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab, case AutomationMsg_RequestStart::ID: if (ui_thread || (url_fetcher_flags_ & PluginUrlRequestManager::START_REQUEST_THREADSAFE)) { - AutomationMsg_RequestStart::Dispatch(&msg, url_fetcher_, + AutomationMsg_RequestStart::Dispatch(&msg, url_fetcher_, this, &PluginUrlRequestManager::StartUrlRequest); return true; } @@ -1112,7 +1112,7 @@ bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab, case AutomationMsg_RequestRead::ID: if (ui_thread || (url_fetcher_flags_ & PluginUrlRequestManager::READ_REQUEST_THREADSAFE)) { - AutomationMsg_RequestRead::Dispatch(&msg, url_fetcher_, + AutomationMsg_RequestRead::Dispatch(&msg, url_fetcher_, this, &PluginUrlRequestManager::ReadUrlRequest); return true; } @@ -1121,7 +1121,7 @@ bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab, case AutomationMsg_RequestEnd::ID: if (ui_thread || (url_fetcher_flags_ & PluginUrlRequestManager::STOP_REQUEST_THREADSAFE)) { - AutomationMsg_RequestEnd::Dispatch(&msg, url_fetcher_, + AutomationMsg_RequestEnd::Dispatch(&msg, url_fetcher_, this, &PluginUrlRequestManager::EndUrlRequest); return true; } @@ -1130,7 +1130,7 @@ bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab, case AutomationMsg_DownloadRequestInHost::ID: if (ui_thread || (url_fetcher_flags_ & PluginUrlRequestManager::DOWNLOAD_REQUEST_THREADSAFE)) { - AutomationMsg_DownloadRequestInHost::Dispatch(&msg, url_fetcher_, + AutomationMsg_DownloadRequestInHost::Dispatch(&msg, url_fetcher_, this, &PluginUrlRequestManager::DownloadUrlRequestInHost); return true; } @@ -1139,7 +1139,7 @@ bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab, case AutomationMsg_GetCookiesFromHost::ID: if (ui_thread || (url_fetcher_flags_ & PluginUrlRequestManager::COOKIE_REQUEST_THREADSAFE)) { - AutomationMsg_GetCookiesFromHost::Dispatch(&msg, url_fetcher_, + AutomationMsg_GetCookiesFromHost::Dispatch(&msg, url_fetcher_, this, &PluginUrlRequestManager::GetCookiesFromHost); return true; } @@ -1148,7 +1148,7 @@ bool ChromeFrameAutomationClient::ProcessUrlRequestMessage(TabProxy* tab, case AutomationMsg_SetCookieAsync::ID: if (ui_thread || (url_fetcher_flags_ & PluginUrlRequestManager::COOKIE_REQUEST_THREADSAFE)) { - AutomationMsg_SetCookieAsync::Dispatch(&msg, url_fetcher_, + AutomationMsg_SetCookieAsync::Dispatch(&msg, url_fetcher_, this, &PluginUrlRequestManager::SetCookiesInHost); return true; } diff --git a/ipc/ipc_message.h b/ipc/ipc_message.h index 5ffddde..accb2e3 100644 --- a/ipc/ipc_message.h +++ b/ipc/ipc_message.h @@ -130,27 +130,29 @@ class Message : public Pickle { header()->routing = new_id; } - template<class T> - static bool Dispatch(const Message* msg, T* obj, void (T::*func)()) { + template<class T, class S> + static bool Dispatch(const Message* msg, T* obj, S* sender, + void (T::*func)()) { (obj->*func)(); return true; } - template<class T> - static bool Dispatch(const Message* msg, T* obj, void (T::*func)() const) { + template<class T, class S> + static bool Dispatch(const Message* msg, T* obj, S* sender, + void (T::*func)() const) { (obj->*func)(); return true; } - template<class T> - static bool Dispatch(const Message* msg, T* obj, + template<class T, class S> + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&)) { (obj->*func)(*msg); return true; } - template<class T> - static bool Dispatch(const Message* msg, T* obj, + template<class T, class S> + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&) const) { (obj->*func)(*msg); return true; diff --git a/ipc/ipc_message_macros.h b/ipc/ipc_message_macros.h index 7247c66..34fd4f4 100644 --- a/ipc/ipc_message_macros.h +++ b/ipc/ipc_message_macros.h @@ -1051,7 +1051,7 @@ void class_name::OnMessageReceived(const IPC::Message& msg) \ #define IPC_MESSAGE_FORWARD(msg_class, obj, member_func) \ case msg_class::ID: \ - msg_is_ok__ = msg_class::Dispatch(&ipc_message__, obj, &member_func); \ + msg_is_ok__ = msg_class::Dispatch(&ipc_message__, obj, this, &member_func); \ break; #define IPC_MESSAGE_HANDLER(msg_class, member_func) \ diff --git a/ipc/ipc_message_utils.h b/ipc/ipc_message_utils.h index eef5a76..b16e05a 100644 --- a/ipc/ipc_message_utils.h +++ b/ipc/ipc_message_utils.h @@ -921,8 +921,8 @@ class MessageWithTuple : public Message { static bool Read(const Message* msg, Param* p) IPC_MSG_NOINLINE; // Generic dispatcher. Should cover most cases. - template<class T, class Method> - static bool Dispatch(const Message* msg, T* obj, Method func) { + template<class T, class S, class Method> + static bool Dispatch(const Message* msg, T* obj, S* sender, Method func) { Param p; if (Read(msg, &p)) { DispatchToMethod(obj, func, p); @@ -934,8 +934,8 @@ class MessageWithTuple : public Message { // The following dispatchers exist for the case where the callback function // needs the message as well. They assume that "Param" is a type of Tuple // (except the one arg case, as there is no Tuple1). - template<class T, typename TA> - static bool Dispatch(const Message* msg, T* obj, + template<class T, class S, typename TA> + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&, TA)) { Param p; if (Read(msg, &p)) { @@ -945,8 +945,8 @@ class MessageWithTuple : public Message { return false; } - template<class T, typename TA, typename TB> - static bool Dispatch(const Message* msg, T* obj, + template<class T, class S, typename TA, typename TB> + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&, TA, TB)) { Param p; if (Read(msg, &p)) { @@ -956,8 +956,8 @@ class MessageWithTuple : public Message { return false; } - template<class T, typename TA, typename TB, typename TC> - static bool Dispatch(const Message* msg, T* obj, + template<class T, class S, typename TA, typename TB, typename TC> + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&, TA, TB, TC)) { Param p; if (Read(msg, &p)) { @@ -967,8 +967,8 @@ class MessageWithTuple : public Message { return false; } - template<class T, typename TA, typename TB, typename TC, typename TD> - static bool Dispatch(const Message* msg, T* obj, + template<class T, class S, typename TA, typename TB, typename TC, typename TD> + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&, TA, TB, TC, TD)) { Param p; if (Read(msg, &p)) { @@ -978,9 +978,9 @@ class MessageWithTuple : public Message { return false; } - template<class T, typename TA, typename TB, typename TC, typename TD, + template<class T, class S, typename TA, typename TB, typename TC, typename TD, typename TE> - static bool Dispatch(const Message* msg, T* obj, + static bool Dispatch(const Message* msg, T* obj, S* sender, void (T::*func)(const Message&, TA, TB, TC, TD, TE)) { Param p; if (Read(msg, &p)) { @@ -1114,8 +1114,8 @@ class MessageWithReply : public SyncMessage { const Message* msg, typename TupleTypes<ReplyParam>::ValueTuple* p) IPC_MSG_NOINLINE; - template<class T, class Method> - static bool Dispatch(const Message* msg, T* obj, Method func) { + template<class T, class S, class Method> + static bool Dispatch(const Message* msg, T* obj, S* sender, Method func) { SendParam send_params; Message* reply = GenerateReply(msg); bool error; @@ -1131,7 +1131,7 @@ class MessageWithReply : public SyncMessage { error = true; } - obj->Send(reply); + sender->Send(reply); return !error; } |