#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/debug/alias.h"
+#include "base/numerics/safe_math.h"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/thread.h"
#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
#include "content/browser/dom_storage/session_storage_namespace_impl.h"
#include "content/browser/download/download_stats.h"
+#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
#include "content/browser/gpu/gpu_data_manager_impl.h"
#include "content/browser/loader/resource_dispatcher_host_impl.h"
#include "content/browser/media/media_internals.h"
#include "content/browser/plugin_process_host.h"
-#include "content/browser/plugin_service_impl.h"
-#include "content/browser/ppapi_plugin_process_host.h"
#include "content/browser/renderer_host/pepper/pepper_security_helper.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/browser/renderer_host/render_view_host_delegate.h"
#include "content/browser/renderer_host/render_widget_helper.h"
+#include "content/browser/renderer_host/render_widget_resize_helper.h"
+#include "content/browser/transition_request_manager.h"
#include "content/common/child_process_host_impl.h"
#include "content/common/child_process_messages.h"
+#include "content/common/content_constants_internal.h"
#include "content/common/cookie_data.h"
#include "content/common/desktop_notification_messages.h"
#include "content/common/frame_messages.h"
#include "content/common/gpu/client/gpu_memory_buffer_impl.h"
+#include "content/common/host_discardable_shared_memory_manager.h"
#include "content/common/host_shared_bitmap_manager.h"
#include "content/common/media/media_param_traits.h"
#include "content/common/view_messages.h"
#include "ui/gfx/color_profile.h"
#if defined(OS_MACOSX)
-#include "content/common/gpu/client/gpu_memory_buffer_impl_io_surface.h"
#include "content/common/mac/font_descriptor.h"
-#include "ui/gl/io_surface_support_mac.h"
#else
#include "gpu/GLES2/gl2extchromium.h"
#include "third_party/khronos/GLES2/gl2.h"
#include "media/base/android/webaudio_media_codec_bridge.h"
#endif
+#if defined(ENABLE_PLUGINS)
+#include "content/browser/plugin_service_impl.h"
+#include "content/browser/ppapi_plugin_process_host.h"
+#endif
+
using net::CookieStore;
namespace content {
const int kPluginsRefreshThresholdInSeconds = 3;
#endif
-// When two CPU usage queries arrive within this interval, we sample the CPU
-// usage only once and send it as a response for both queries.
-static const int64 kCPUUsageSampleIntervalMs = 900;
-
const uint32 kFilteredMessageClasses[] = {
ChildProcessMsgStart,
DesktopNotificationMsgStart,
IPC::Message* reply_msg_;
};
+#if defined(ENABLE_PLUGINS)
class OpenChannelToPpapiPluginCallback
: public RenderMessageCompletionCallback,
public PpapiPluginProcessHost::PluginClient {
context_(context) {
}
- virtual void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
- int* renderer_id) OVERRIDE {
+ void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
+ int* renderer_id) override {
*renderer_handle = filter()->PeerHandle();
*renderer_id = filter()->render_process_id();
}
- virtual void OnPpapiChannelOpened(const IPC::ChannelHandle& channel_handle,
- base::ProcessId plugin_pid,
- int plugin_child_id) OVERRIDE {
+ void OnPpapiChannelOpened(const IPC::ChannelHandle& channel_handle,
+ base::ProcessId plugin_pid,
+ int plugin_child_id) override {
ViewHostMsg_OpenChannelToPepperPlugin::WriteReplyParams(
reply_msg(), channel_handle, plugin_pid, plugin_child_id);
SendReplyAndDeleteThis();
}
- virtual bool OffTheRecord() OVERRIDE {
- return filter()->OffTheRecord();
- }
+ bool OffTheRecord() override { return filter()->OffTheRecord(); }
- virtual ResourceContext* GetResourceContext() OVERRIDE {
- return context_;
- }
+ ResourceContext* GetResourceContext() override { return context_; }
private:
ResourceContext* context_;
routing_id_(routing_id) {
}
- virtual ~OpenChannelToPpapiBrokerCallback() {}
+ ~OpenChannelToPpapiBrokerCallback() override {}
- virtual void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
- int* renderer_id) OVERRIDE {
+ void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
+ int* renderer_id) override {
*renderer_handle = filter_->PeerHandle();
*renderer_id = filter_->render_process_id();
}
- virtual void OnPpapiChannelOpened(const IPC::ChannelHandle& channel_handle,
- base::ProcessId plugin_pid,
- int /* plugin_child_id */) OVERRIDE {
+ void OnPpapiChannelOpened(const IPC::ChannelHandle& channel_handle,
+ base::ProcessId plugin_pid,
+ int /* plugin_child_id */) override {
filter_->Send(new ViewMsg_PpapiBrokerChannelCreated(routing_id_,
plugin_pid,
channel_handle));
delete this;
}
- virtual bool OffTheRecord() OVERRIDE {
- return filter_->OffTheRecord();
- }
+ bool OffTheRecord() override { return filter_->OffTheRecord(); }
private:
scoped_refptr<RenderMessageFilter> filter_;
int routing_id_;
};
-
-#if defined(OS_MACOSX)
-void AddBooleanValue(CFMutableDictionaryRef dictionary,
- const CFStringRef key,
- bool value) {
- CFDictionaryAddValue(
- dictionary, key, value ? kCFBooleanTrue : kCFBooleanFalse);
-}
-
-void AddIntegerValue(CFMutableDictionaryRef dictionary,
- const CFStringRef key,
- int32 value) {
- base::ScopedCFTypeRef<CFNumberRef> number(
- CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
- CFDictionaryAddValue(dictionary, key, number.get());
-}
-#endif
+#endif // defined(ENABLE_PLUGINS)
} // namespace
sent_plugin_channel_request_(false) {
}
- virtual int ID() OVERRIDE {
- return filter()->render_process_id();
- }
+ int ID() override { return filter()->render_process_id(); }
- virtual ResourceContext* GetResourceContext() OVERRIDE {
- return context_;
- }
+ ResourceContext* GetResourceContext() override { return context_; }
- virtual bool OffTheRecord() OVERRIDE {
+ bool OffTheRecord() override {
if (filter()->OffTheRecord())
return true;
if (GetContentClient()->browser()->AllowSaveLocalState(context_))
return false;
}
- virtual void SetPluginInfo(const WebPluginInfo& info) OVERRIDE {
- info_ = info;
- }
+ void SetPluginInfo(const WebPluginInfo& info) override { info_ = info; }
- virtual void OnFoundPluginProcessHost(PluginProcessHost* host) OVERRIDE {
+ void OnFoundPluginProcessHost(PluginProcessHost* host) override {
DCHECK(host);
host_ = host;
}
- virtual void OnSentPluginChannelRequest() OVERRIDE {
+ void OnSentPluginChannelRequest() override {
sent_plugin_channel_request_ = true;
}
- virtual void OnChannelOpened(const IPC::ChannelHandle& handle) OVERRIDE {
+ void OnChannelOpened(const IPC::ChannelHandle& handle) override {
WriteReplyAndDeleteThis(handle);
}
- virtual void OnError() OVERRIDE {
- WriteReplyAndDeleteThis(IPC::ChannelHandle());
- }
+ void OnError() override { WriteReplyAndDeleteThis(IPC::ChannelHandle()); }
PluginProcessHost* host() const {
return host_;
RenderMessageFilter::RenderMessageFilter(
int render_process_id,
- bool is_guest,
PluginServiceImpl* plugin_service,
BrowserContext* browser_context,
net::URLRequestContextGetter* request_context,
incognito_(browser_context->IsOffTheRecord()),
dom_storage_context_(dom_storage_context),
render_process_id_(render_process_id),
- is_guest_(is_guest),
- cpu_usage_(0),
audio_manager_(audio_manager),
media_internals_(media_internals) {
DCHECK(request_context_.get());
- render_widget_helper_->Init(render_process_id_, resource_dispatcher_host_);
+ if (render_widget_helper)
+ render_widget_helper_->Init(render_process_id_, resource_dispatcher_host_);
}
RenderMessageFilter::~RenderMessageFilter() {
// This function should be called on the IO thread.
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(plugin_host_clients_.empty());
+ HostSharedBitmapManager::current()->ProcessRemoved(PeerHandle());
+ BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager =
+ BrowserGpuMemoryBufferManager::current();
+ if (gpu_memory_buffer_manager)
+ gpu_memory_buffer_manager->ProcessRemoved(PeerHandle(), render_process_id_);
+ HostDiscardableSharedMemoryManager::current()->ProcessRemoved(PeerHandle());
}
void RenderMessageFilter::OnChannelClosing() {
- HostSharedBitmapManager::current()->ProcessRemoved(PeerHandle());
#if defined(ENABLE_PLUGINS)
for (std::set<OpenChannelToNpapiPluginCallback*>::iterator it =
plugin_host_clients_.begin(); it != plugin_host_clients_.end(); ++it) {
plugin_host_clients_.clear();
}
-void RenderMessageFilter::OnChannelConnected(int32 peer_id) {
- base::ProcessHandle handle = PeerHandle();
-#if defined(OS_MACOSX)
- process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle,
- NULL));
-#else
- process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
-#endif
- cpu_usage_ = process_metrics_->GetCPUUsage(); // Initialize CPU usage counters
- cpu_usage_sample_time_ = base::TimeTicks::Now();
-}
-
-bool RenderMessageFilter::OnMessageReceived(const IPC::Message& message,
- bool* message_was_ok) {
+bool RenderMessageFilter::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
- IPC_BEGIN_MESSAGE_MAP_EX(RenderMessageFilter, message, *message_was_ok)
+ IPC_BEGIN_MESSAGE_MAP(RenderMessageFilter, message)
#if defined(OS_WIN)
IPC_MESSAGE_HANDLER(ViewHostMsg_PreCacheFontCharacters,
OnPreCacheFontCharacters)
IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_LoadFont, OnLoadFont)
#endif
IPC_MESSAGE_HANDLER(ViewHostMsg_DownloadUrl, OnDownloadUrl)
+ IPC_MESSAGE_HANDLER(ViewHostMsg_SaveImageFromDataURL,
+ OnSaveImageFromDataURL)
#if defined(ENABLE_PLUGINS)
IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_GetPlugins, OnGetPlugins)
IPC_MESSAGE_HANDLER(FrameHostMsg_GetPluginInfo, OnGetPluginInfo)
IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToPpapiBroker,
OnOpenChannelToPpapiBroker)
#endif
+#if defined(OS_MACOSX)
+ IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_SwapCompositorFrame,
+ RenderWidgetResizeHelper::Get()->PostRendererProcessMsg(
+ render_process_id_, message))
IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_UpdateRect,
- render_widget_helper_->DidReceiveBackingStoreMsg(message))
- IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateIsDelayed, OnUpdateIsDelayed)
+ RenderWidgetResizeHelper::Get()->PostRendererProcessMsg(
+ render_process_id_, message))
+#endif
IPC_MESSAGE_HANDLER(DesktopNotificationHostMsg_CheckPermission,
OnCheckNotificationPermission)
IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateSharedMemory,
OnAllocateSharedMemory)
- IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateSharedBitmap,
- OnAllocateSharedBitmap)
- IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer,
- OnAllocateGpuMemoryBuffer)
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(
+ ChildProcessHostMsg_SyncAllocateSharedBitmap, OnAllocateSharedBitmap)
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(
+ ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer,
+ OnAllocateGpuMemoryBuffer)
+ IPC_MESSAGE_HANDLER(ChildProcessHostMsg_DeletedGpuMemoryBuffer,
+ OnDeletedGpuMemoryBuffer)
IPC_MESSAGE_HANDLER(ChildProcessHostMsg_AllocatedSharedBitmap,
OnAllocatedSharedBitmap)
IPC_MESSAGE_HANDLER(ChildProcessHostMsg_DeletedSharedBitmap,
OnDeletedSharedBitmap)
-#if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
+ IPC_MESSAGE_HANDLER(
+ ChildProcessHostMsg_SyncAllocateLockedDiscardableSharedMemory,
+ OnAllocateLockedDiscardableSharedMemory)
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
IPC_MESSAGE_HANDLER(ViewHostMsg_AllocTransportDIB, OnAllocTransportDIB)
IPC_MESSAGE_HANDLER(ViewHostMsg_FreeTransportDIB, OnFreeTransportDIB)
#endif
IPC_MESSAGE_HANDLER(ViewHostMsg_DidGenerateCacheableMetadata,
OnCacheableMetadataAvailable)
IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_Keygen, OnKeygen)
- IPC_MESSAGE_HANDLER(ViewHostMsg_GetCPUUsage, OnGetCPUUsage)
IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioHardwareConfig,
OnGetAudioHardwareConfig)
#if defined(OS_WIN)
#if defined(OS_ANDROID)
IPC_MESSAGE_HANDLER(ViewHostMsg_RunWebAudioMediaCodec, OnWebAudioMediaCodec)
#endif
+ IPC_MESSAGE_HANDLER(FrameHostMsg_AddNavigationTransitionData,
+ OnAddNavigationTransitionData)
IPC_MESSAGE_UNHANDLED(handled = false)
- IPC_END_MESSAGE_MAP_EX()
+ IPC_END_MESSAGE_MAP()
return handled;
}
params.opener_suppressed,
resource_context_,
render_process_id_,
- is_guest_,
params.opener_id,
&no_javascript_access);
*route_id = MSG_ROUTING_NONE;
*main_frame_route_id = MSG_ROUTING_NONE;
*surface_id = 0;
+ *cloned_session_storage_namespace_id = 0;
return;
}
void RenderMessageFilter::OnGetProcessMemorySizes(size_t* private_bytes,
size_t* shared_bytes) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
using base::ProcessMetrics;
#if !defined(OS_MACOSX) || defined(OS_IOS)
scoped_ptr<ProcessMetrics> metrics(ProcessMetrics::CreateProcessMetrics(
PeerHandle()));
#else
scoped_ptr<ProcessMetrics> metrics(ProcessMetrics::CreateProcessMetrics(
- PeerHandle(), content::BrowserChildProcessHost::GetPortProvider()));
+ PeerHandle(), BrowserChildProcessHost::GetPortProvider()));
#endif
if (!metrics->GetMemoryBytes(private_bytes, shared_bytes)) {
*private_bytes = 0;
}
void RenderMessageFilter::OnCookiesEnabled(
+ int render_frame_id,
const GURL& url,
const GURL& first_party_for_cookies,
bool* cookies_enabled) {
// host.
*cookies_enabled = GetContentClient()->browser()->AllowGetCookie(
url, first_party_for_cookies, net::CookieList(), resource_context_,
- render_process_id_, MSG_ROUTING_CONTROL);
+ render_process_id_, render_frame_id);
}
#if defined(OS_MACOSX)
*route_id = render_widget_helper_->GetNextRoutingID();
}
-void RenderMessageFilter::OnGetCPUUsage(int* cpu_usage) {
- base::TimeTicks now = base::TimeTicks::Now();
- int64 since_last_sample_ms = (now - cpu_usage_sample_time_).InMilliseconds();
- if (since_last_sample_ms > kCPUUsageSampleIntervalMs) {
- cpu_usage_sample_time_ = now;
- cpu_usage_ = static_cast<int>(process_metrics_->GetCPUUsage());
- }
- *cpu_usage = cpu_usage_;
-}
-
void RenderMessageFilter::OnGetAudioHardwareConfig(
media::AudioParameters* input_params,
media::AudioParameters* output_params) {
#if defined(OS_WIN)
void RenderMessageFilter::OnGetMonitorColorProfile(std::vector<char>* profile) {
DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
- static bool enabled = false;
- static bool checked = false;
- if (!checked) {
- checked = true;
- const CommandLine& command = *CommandLine::ForCurrentProcess();
- enabled = command.HasSwitch(switches::kEnableMonitorProfile);
- }
- if (enabled)
- return;
*profile = g_color_profile.Get().profile();
}
#endif
-void RenderMessageFilter::OnDownloadUrl(const IPC::Message& message,
- const GURL& url,
- const Referrer& referrer,
- const base::string16& suggested_name) {
+void RenderMessageFilter::DownloadUrl(int render_view_id,
+ const GURL& url,
+ const Referrer& referrer,
+ const base::string16& suggested_name,
+ const bool use_prompt) const {
scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
save_info->suggested_name = suggested_name;
+ save_info->prompt_for_save_location = use_prompt;
// There may be a special cookie store that we could use for this download,
// rather than the default one. Since this feature is generally only used for
// default cookie store.
// TODO(tburkard): retrieve the appropriate special cookie store, if this
// is ever to be used for downloads as well.
+
scoped_ptr<net::URLRequest> request(
resource_context_->GetRequestContext()->CreateRequest(
url, net::DEFAULT_PRIORITY, NULL, NULL));
true, // is_content_initiated
resource_context_,
render_process_id_,
- message.routing_id(),
+ render_view_id,
false,
save_info.Pass(),
- content::DownloadItem::kInvalidId,
+ DownloadItem::kInvalidId,
ResourceDispatcherHostImpl::DownloadStartedCallback());
}
+void RenderMessageFilter::OnDownloadUrl(int render_view_id,
+ const GURL& url,
+ const Referrer& referrer,
+ const base::string16& suggested_name) {
+ DownloadUrl(render_view_id, url, referrer, suggested_name, false);
+}
+
+void RenderMessageFilter::OnSaveImageFromDataURL(int render_view_id,
+ const std::string& url_str) {
+ // Please refer to RenderViewImpl::saveImageFromDataURL().
+ if (url_str.length() >= kMaxLengthOfDataURLString)
+ return;
+
+ GURL data_url(url_str);
+ if (!data_url.SchemeIs(url::kDataScheme))
+ return;
+
+ DownloadUrl(render_view_id, data_url, Referrer(), base::string16(), true);
+}
+
void RenderMessageFilter::OnCheckNotificationPermission(
const GURL& source_origin, int* result) {
#if defined(ENABLE_NOTIFICATIONS)
buffer_size, PeerHandle(), handle);
}
-void RenderMessageFilter::OnAllocateSharedBitmap(
+void RenderMessageFilter::AllocateSharedBitmapOnFileThread(
uint32 buffer_size,
const cc::SharedBitmapId& id,
- base::SharedMemoryHandle* handle) {
+ IPC::Message* reply_msg) {
+ base::SharedMemoryHandle handle;
HostSharedBitmapManager::current()->AllocateSharedBitmapForChild(
- PeerHandle(), buffer_size, id, handle);
+ PeerHandle(), buffer_size, id, &handle);
+ ChildProcessHostMsg_SyncAllocateSharedBitmap::WriteReplyParams(reply_msg,
+ handle);
+ Send(reply_msg);
+}
+
+void RenderMessageFilter::OnAllocateSharedBitmap(uint32 buffer_size,
+ const cc::SharedBitmapId& id,
+ IPC::Message* reply_msg) {
+ BrowserThread::PostTask(
+ BrowserThread::FILE_USER_BLOCKING,
+ FROM_HERE,
+ base::Bind(&RenderMessageFilter::AllocateSharedBitmapOnFileThread,
+ this,
+ buffer_size,
+ id,
+ reply_msg));
}
void RenderMessageFilter::OnAllocatedSharedBitmap(
HostSharedBitmapManager::current()->ChildDeletedSharedBitmap(id);
}
+void RenderMessageFilter::OnAllocateLockedDiscardableSharedMemory(
+ uint32 size,
+ base::SharedMemoryHandle* handle) {
+ HostDiscardableSharedMemoryManager::current()
+ ->AllocateLockedDiscardableSharedMemoryForChild(
+ PeerHandle(), size, handle);
+}
+
net::CookieStore* RenderMessageFilter::GetCookieStoreForURL(
const GURL& url) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
net::URLRequestContext* context =
GetContentClient()->browser()->OverrideRequestContextForURL(
return request_context_->GetURLRequestContext()->cookie_store();
}
-#if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
void RenderMessageFilter::OnAllocTransportDIB(
uint32 size, bool cache_in_browser, TransportDIB::Handle* handle) {
render_widget_helper_->AllocTransportDIB(size, cache_in_browser, handle);
}
#endif
-bool RenderMessageFilter::CheckPreparsedJsCachingEnabled() const {
- static bool checked = false;
- static bool result = false;
- if (!checked) {
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
- result = command_line.HasSwitch(switches::kEnablePreparsedJsCaching);
- checked = true;
- }
- return result;
-}
-
void RenderMessageFilter::OnCacheableMetadataAvailable(
const GURL& url,
double expected_response_time,
const std::vector<char>& data) {
- if (!CheckPreparsedJsCachingEnabled())
- return;
-
net::HttpCache* cache = request_context_->GetURLRequestContext()->
http_transaction_factory()->GetCache();
DCHECK(cache);
void RenderMessageFilter::OnCompletedOpenChannelToNpapiPlugin(
OpenChannelToNpapiPluginCallback* client) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(ContainsKey(plugin_host_clients_, client));
plugin_host_clients_.erase(client);
}
-void RenderMessageFilter::OnUpdateIsDelayed(const IPC::Message& msg) {
- // When not in accelerated compositing mode, in certain cases (e.g. waiting
- // for a resize or if no backing store) the RenderWidgetHost is blocking the
- // UI thread for some time, waiting for an UpdateRect from the renderer. If we
- // are going to switch to accelerated compositing, the GPU process may need
- // round-trips to the UI thread before finishing the frame, causing deadlocks
- // if we delay the UpdateRect until we receive the OnSwapBuffersComplete. So
- // the renderer sent us this message, so that we can unblock the UI thread.
- // We will simply re-use the UpdateRect unblock mechanism, just with a
- // different message.
- render_widget_helper_->DidReceiveBackingStoreMsg(msg);
-}
-
void RenderMessageFilter::OnAre3DAPIsBlocked(int render_view_id,
const GURL& top_origin_url,
ThreeDAPIType requester,
#if defined(OS_WIN)
void RenderMessageFilter::OnPreCacheFontCharacters(const LOGFONT& font,
const base::string16& str) {
- // TODO(scottmg): Move this to FontCacheDispatcher, http://crbug.com/356346.
- if (!ShouldUseDirectWrite())
- return;
+ // TODO(scottmg): pdf/ppapi still require the renderer to be able to precache
+ // GDI fonts (http://crbug.com/383227), even when using DirectWrite.
+ // Eventually this shouldn't be added and should be moved to
+ // FontCacheDispatcher too. http://crbug.com/356346.
+
// First, comments from FontCacheDispatcher::OnPreCacheFont do apply here too.
// Except that for True Type fonts,
// GetTextMetrics will not load the font in memory.
}
#endif
+void RenderMessageFilter::OnAddNavigationTransitionData(
+ FrameHostMsg_AddNavigationTransitionData_Params params) {
+ if (params.elements.size() > TransitionRequestManager::kMaxNumOfElements)
+ return;
+ TransitionRequestManager::GetInstance()->AddPendingTransitionRequestData(
+ render_process_id_,
+ params.render_frame_id,
+ params.allowed_destination_host_pattern,
+ params.selector,
+ params.markup,
+ params.elements);
+}
+
void RenderMessageFilter::OnAllocateGpuMemoryBuffer(
uint32 width,
uint32 height,
- uint32 internalformat,
- gfx::GpuMemoryBufferHandle* handle) {
- if (!GpuMemoryBufferImpl::IsFormatValid(internalformat)) {
- handle->type = gfx::EMPTY_BUFFER;
+ gfx::GpuMemoryBuffer::Format format,
+ gfx::GpuMemoryBuffer::Usage usage,
+ IPC::Message* reply) {
+ DCHECK(BrowserGpuMemoryBufferManager::current());
+
+ base::CheckedNumeric<int> size = width;
+ size *= height;
+ if (!size.IsValid()) {
+ GpuMemoryBufferAllocated(reply, gfx::GpuMemoryBufferHandle());
return;
}
-#if defined(OS_MACOSX)
- if (GpuMemoryBufferImplIOSurface::IsFormatSupported(internalformat)) {
- IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
- if (io_surface_support) {
- base::ScopedCFTypeRef<CFMutableDictionaryRef> properties;
- properties.reset(
- CFDictionaryCreateMutable(kCFAllocatorDefault,
- 0,
- &kCFTypeDictionaryKeyCallBacks,
- &kCFTypeDictionaryValueCallBacks));
- AddIntegerValue(properties,
- io_surface_support->GetKIOSurfaceWidth(),
- width);
- AddIntegerValue(properties,
- io_surface_support->GetKIOSurfaceHeight(),
- height);
- AddIntegerValue(properties,
- io_surface_support->GetKIOSurfaceBytesPerElement(),
- GpuMemoryBufferImpl::BytesPerPixel(internalformat));
- AddIntegerValue(properties,
- io_surface_support->GetKIOSurfacePixelFormat(),
- GpuMemoryBufferImplIOSurface::PixelFormat(
- internalformat));
- // TODO(reveman): Remove this when using a mach_port_t to transfer
- // IOSurface to renderer process. crbug.com/323304
- AddBooleanValue(properties,
- io_surface_support->GetKIOSurfaceIsGlobal(),
- true);
-
- base::ScopedCFTypeRef<CFTypeRef> io_surface(
- io_surface_support->IOSurfaceCreate(properties));
- if (io_surface) {
- handle->type = gfx::IO_SURFACE_BUFFER;
- handle->io_surface_id = io_surface_support->IOSurfaceGetID(io_surface);
-
- // TODO(reveman): This makes the assumption that the renderer will
- // grab a reference to the surface before sending another message.
- // crbug.com/325045
- last_io_surface_ = io_surface;
- return;
- }
- }
- }
-#endif
+ BrowserGpuMemoryBufferManager::current()
+ ->AllocateGpuMemoryBufferForChildProcess(
+ gfx::Size(width, height),
+ format,
+ usage,
+ PeerHandle(),
+ render_process_id_,
+ base::Bind(
+ &RenderMessageFilter::GpuMemoryBufferAllocated, this, reply));
+}
- uint64 stride = static_cast<uint64>(width) *
- GpuMemoryBufferImpl::BytesPerPixel(internalformat);
- if (stride > std::numeric_limits<uint32>::max()) {
- handle->type = gfx::EMPTY_BUFFER;
- return;
- }
+void RenderMessageFilter::GpuMemoryBufferAllocated(
+ IPC::Message* reply,
+ const gfx::GpuMemoryBufferHandle& handle) {
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
+ ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer::WriteReplyParams(reply,
+ handle);
+ Send(reply);
+}
- uint64 buffer_size = stride * static_cast<uint64>(height);
- if (buffer_size > std::numeric_limits<size_t>::max()) {
- handle->type = gfx::EMPTY_BUFFER;
- return;
- }
+void RenderMessageFilter::OnDeletedGpuMemoryBuffer(
+ gfx::GpuMemoryBufferId id,
+ uint32 sync_point) {
+ DCHECK(BrowserGpuMemoryBufferManager::current());
- // Fallback to fake GpuMemoryBuffer that is backed by shared memory and
- // requires an upload before it can be used as a texture.
- handle->type = gfx::SHARED_MEMORY_BUFFER;
- ChildProcessHostImpl::AllocateSharedMemory(
- static_cast<size_t>(buffer_size), PeerHandle(), &handle->handle);
+ BrowserGpuMemoryBufferManager::current()->ChildProcessDeletedGpuMemoryBuffer(
+ id, PeerHandle(), render_process_id_, sync_point);
}
} // namespace content
projects / platform / framework / web / crosswalk.git / blobdiff