Phil Bouchard | 22 Dec 05:53 2014

Memory Manager


I wrote a deterministic memory manager in C++ and I was wondering if 
their is any interests introducing it into Webkit, thus speeding up Webkit.

The memory manager is located here:

Sincerely yours,
Geoffrey Garen | 16 Dec 02:31 2014

If you like writing memory smashers, you'll love this

As of r177317, FastMalloc can be disabled at runtime. This means that you can use system memory analysis
tools like GuardMalloc, MallocScribble, Instruments allocation tracking, leaks, and heap to debug
memory issues in WebKit nightly builds, spade builds, and release builds.

FastMalloc automatically disables itself in the presence of environment variables that enable Malloc
debugging APIs. For giggles, you can also manually disable FastMalloc by setting the “Malloc”
environment variable to “1”.

Happy memory smashing.

webkit-dev mailing list
webkit-dev <at>
Andreas Kling | 15 Dec 19:44 2014

A quick note on Ref and RefPtr changes

Howdy folks,

Thanks to the magic of C++11, we don’t need PassRef and PassRefPtr anymore, as we can use rvalue
references and move semantics to achieve churn-free ownership transfers.

I’ve already removed PassRef entirely, and PassRefPtr will be next. Given how widely it’s used in the
codebase, I expect it will take some time.

Here’s the endgame I’m shooting for:

Ref<T> is used for all ownership-sharing pointers known to be non-null. It cannot be null.
RefPtr<T> is used for pointers that need a null state.

Return values that were previously PassRef<T> or PassRefPtr<T> will become Ref<T> or RefPtr<T>.

Arguments that were previously PassRef<T> or PassRefPtr<T> will become Ref<T>&& or RefPtr<T>&&.

You will need to WTF::move() when transferring ownership. This is different from the PassRefPtr way,
where ownership could be transferred without visual indication at the call site.

To pass a local RefPtr to a function f(RefPtr&&) *without* transferring ownership, use
Ref/RefPtr::copyRef() to keep the local reference on the object.

Important note: After you’ve WTF::move()’d out of a Ref, it’s in an invalid state and cannot be used
again. I’m working on a solution to turn this into a compile-time error.


PS. Once the kinks are ironed out, I’ll also be updating the RefPtr documentation on
(Continue reading)

David Kilzer | 15 Dec 19:04 2014

Interdiff fixed on

I just fixed the ‘interdiff’ feature of Bugzilla.  Now you can diff your diffs while you diff!

webkit-dev mailing list
webkit-dev <at>
Ian Ragsdale | 12 Dec 01:50 2014

DropAllLocks assertion on iOS (threading issue?)

Hello all, new member to the list, hopefully I'm in the right place.

I'm using WebKit in an iOS app (via UIWebView), and we're seeing a semi-frequent crash that I'm trying to
track down. From the backtraces, I _think_ it appears to be a WebKit bug, and so I'd like to try to find a
workaround, and/or submit a useful bug or patch.

A full thread dump is available here:

The assertion appears to be happening when the WebThread tries to call my delegate to decide whether to load
a URL:

Thread : Crashed: WebThread
0  JavaScriptCore                 0x27e864aa WTFCrash + 53
1  JavaScriptCore                 0x27e86457 WTFPrintBacktrace + 130
2  JavaScriptCore                 0x27dc92e1 JSC::JSLock::DropAllLocks::DropAllLocks(JSC::VM*)
3  WebCore                        0x31cd3061 SendDelegateMessage(NSInvocation*) + 184
4  WebKitLegacy                   0x327be1f5 -[_WebSafeForwarder forwardInvocation:] + 116
5  CoreFoundation                 0x269d766f ___forwarding___ + 354
6  CoreFoundation                 0x26909058 _CF_forwarding_prep_0 + 24
7  WebKitLegacy                   0x327ffb01
const&, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>,
std::__1::function<void (WebCore::PolicyAction)>) + 344

From looking at the source, it tries to drop all locks from the current javascript VM before calling the
delegate, and when it does that it asserts if the VM is busy garbage collecting. I'm guessing there needs to
be some sort of guard there to make sure the VM isn't doing GC before dropping the locks?

I'm pretty positive I'm not calling into the UIWebView from any thread other than the main thread, and I
don't think I have any control over the WebThread or the GC threads, so I'm not sure if there's anything I can
do, but I do have a fairly reliable repro, so if there's something it makes sense for me to test, I can do so.

The one thing I can think of that could be causing issues on our end is that we're using a custom NSURLProtocol
for loading some of the data, but I can't ever find it in the stack traces, so I don't think that's it.

Any suggestions?

Thanks in advance,

Attachment (smime.p7s): application/pkcs7-signature, 6524 bytes
webkit-dev mailing list
webkit-dev <at>
Ryosuke Niwa | 10 Dec 22:46 2014

WKR and webkitbot going offline tonight


Due to our lab downtime, WKR and webkitbot IRC bots are going down tonight.  They should come back up by early tomorrow morning but please let me know if they don't.

Meanwhile, you can manually rollout/revert a patch via "webkit-patch rollout" command, and you can always subscribe to webkit-changes list to receive emails for every change made in WebKit.

- R. Niwa

webkit-dev mailing list
webkit-dev <at>
Lucas Forschler | 9 Dec 22:41 2014

Apple owned buildbot slaves down Wednesday and Thursday evenings.

Hello all,

We are upgrading our infrastructure for the Apple owned WebKit build and test fleet. This will require some downtime on Wednesday and Thursday evenings (Dec 10 and 11th). The planned downtime will start at approximately 3pm both days. We expect the affected machines will be back online by 8 am the following day.

Please note that * servers will not be down during this time.

Please let me know if you have any concerns.


webkit-dev mailing list
webkit-dev <at>
Žan Doberšek | 9 Dec 16:28 2014

Announcing WebKit for Wayland

Igalia is happy to announce the Wayland port of WebKit.
This port avoids using traditional GUI toolkits in favor of directly operating with the Wayland display protocol. Leveraging the WebKit2 multi-process architecture, the UIProcess is implemented as a shared library and loaded by the Wayland compositor, enabling the WebProcess to act as a direct client of the compositor while still being controlled by the UIProcess.
EGL, the Wayland EGL platform, and OpenGL ES are used for hardware-accelerated compositing of the rendered Web content. GLib, Libsoup and Cairo are used under the hood.
The port serves as a good base for building systems and environments that are mostly or completely relying on the Web platform technologies for building the desired interface.
Overall the port is still in its early days, with some basic functionality (e.g. functional keyboard and mouse input support) and many other Web platform features still not supported. But with Wayland EGL support constantly growing in graphics drivers for different GPUs, it can already be tested on devices like the Raspberry Pi or the Jetson TK1 development board.
In terms of supported Wayland compositors, for the moment we only support Weston (the reference Wayland compositor implementation), which is also used for development purposes. It's also used for running the layout tests by again pushing WebKitTestRunner functionality into a shared library, though all that is still in very early stages.
The code is available on GitHub. There are also short instructions for building the dependencies and the port, and how to run it.
There's also additional repositories there (for Cairo, Weston), containing changes that haven't yet been pushed upstream. In the following days we'll also be providing Buildroot configurations that can be used for cross-compiling the whole software stack for the supported hardware.
We look forward to continuing evolving this work, enabling further features and improving performance on the software side and adding support for additional devices. As with all open-source projects, contributions are welcome.
Regards,Zan Dobersek
webkit-dev mailing list
webkit-dev <at>
Vienneau, Christopher | 6 Dec 01:47 2014

Web Inspector Memory Tools



I was taking a look at the feature set that the web inspector offers, hoping to find something showing how memory is being used for a given page (images, JS, CSS ect).  I couldn’t find what I was looking for.  I notice in chrome they have something that allows you to take  a heap snapshot which is a step in that direction.  Are there any plans for memory profiling features?




Chris Vienneau

webkit-dev mailing list
webkit-dev <at>
Osztrogonác Csaba | 5 Dec 15:38 2014

Do we need ENABLE(SQL_DATABASE) guards?

Hi all,

it seems ENABLE(SQL_DATABASE) is enabled on all ports,
but there are still ifdef guards for it in 300+ files.

Is there anybody shipping WebKit with disabled SQL_DATABASE?
If no, I'd propopse removing these guards.

Daniel Lazarenko | 3 Dec 11:32 2014

review times


I’ve made a patch for a bug # 137299, and it’s been waiting for review for more than 30 days now. The
responsible reviewer from Apple is too busy to review. On the other hand there are patches sent by Apple
employees and committed after 2 hours without any review ( for example # 138971 ). This looks very unfair to
me. I was always thinking that open source projects are open to changes and collaboration. There should be
some rules for such cases when only one person can review, but he/she is so busy that practically it’s not
going to happen.

Whatsoever it would be nice find a new reviewer for my patch. Does anybody want to take it?

With best regards,
Daniel Lazarenko
Opera Software ASA

webkit-dev mailing list
webkit-dev <at>