I worked as the Lead OS Architect for Jolicloud (Joli OS) for the past few years, and have also done quite a bit of work customizing Chromium OS for other projects. To answer your question, I can definitely say it's the latter for both OSes:
The structure of a web browser based OS is a persistent browser running over stripped-down Linux based OS.
Joli OS and Chrome OS have some similarities in core design, and some key differences between each other and when compared to a more traditional Linux OS. Let me explain :)
Joli OS uses a Ubuntu-based Linux foundation (which supplies the kernel, X.org, user-space drivers, UI, etc) I worked to strip out as much as possible of the Gnome-based UI and local applications, providing as much of the UX as possible through an HTML5 web app interface. So, from the computer's perspective, when Joli OS starts the Kernel kicks in, which loads the system drivers, user-space drivers, and user-space init scripts. These scripts kick off X.org, which load our session manager, which in turn loads a stripped Gnome shell, and then finally Chromium to the http://my.jolicloud.com start page.
Chrome OS is very similar in this design, except a few key differences: First, it uses a Gentoo-based foundation (Google did used to use Ubuntu, but switched away from it in early 2010). Second, after the Kernel, drivers, and X.org start, Chrome itself handles the session manager which actually "logs in" the user. (This step also decrypts the user home directory, and provides other security features.) Furthermore, rather than a Gnome shell, Chrome also handles traditional window-manager system features like wifi configuration, user accounts, and initiating shutdown and suspend events, etc. Finally, a local start page showing the Chrome web apps installed loads alongside the traditional web browser UI.
In summary, the major difference in the structure of Chrome OS is that Chrome itself is fulfilling more and more of the UX tasks that have been traditionally provided by session- and window-managers like Gnome. By doing everything in the browser, and removing local apps entirely (Incidentally, Joli OS strives to maintain legacy local apps) a faster and more efficient boot-up experience can be presented to the user. Additional differences exist through, i.e., Chrome OS modifies the Kernel, drivers, startup-scripts, and X.org itself to work more efficiently to the target hardware that Chrome OS is designed for.
Don't forget that Ubuntu, Gentoo, and even Joli OS are all designed to have one ISO build run on as many hardware variants as possible, but Chrome OS is designed to only run on a very specific hardware profile. This is another major difference: Chrome OS can strip out suppport for the non-target hardware profiles at build time, also resulting in a more efficient UX with a smaller distribution and boot partition.
Hope this helps :)
Before coming to iptables, it is not the only thing you need. First, on the host you must enable IPv4 forwarding,
echo 1 > /proc/sys/net/ipv4/ip_forward
and, on the guest, you must setup a default gateway,
ip route add default via 192.168.56.1 dev eth0
if your internal adapter is using the subnet 192.168.56.0/24 (the default), otherwise change accordingly.
As for iptables: packets coming thru the internal adapter and trying to reach the internet will carry as a source address that of the guest, which on your LAN of course no one knows since it belongs to a different subnet, 192.168.56.1. So it will never receive a reply. Thus we need an iptables rule which will re-write the source address to be that of the host, which can be reached by your router/modem/gateway. iptables itself will keep track of the connection so that the reply packets will be sent correctly to the guest, instead of being withheld by the host; there is no need for us to do anything.
Both of these iptables rules will work,
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 192.168.1.15
(the above assues that the host has IP address 192.168.1.15 and is connected to your modem/gateway/router via eth0; if not, change accordingly). The difference between these two statements is clear: with SNAT you must explicitly state the interface's IP address, with MASQUERADE you do not. So, if for any reason your interface IP address changes, the rule with SNAT is not correct any longer, while the one with MASQUERADE (which checks the IP address every time it is used) you do not need to adjust the rule. Obviously, MASQUERADE is a tad slower than SNAT.
Personally, I prefer MASQUERADE because it makes my firewall configuration portable, but, as they say, YMMV.
Best Answer
The main difference is the default window manager. Xubuntu and Lubuntu are usually used with older and less powerful computers. In detail:
Ubuntu comes with Unity a shell running over the GNOME Desktop environment. Unity is mean to be easy to use for most users.
Kubuntu uses KDE as the default desktop environment. KDE has got a lot of configurations and graphic effects and is good for power users who want to costumize a lot their environment.
Xubuntu uses XFCE a very clean desktop environment. XFCE is easy to use and uses less system resources than KDE and Unity (Gnome).
Lubuntu uses LXDE as the the window manager. LXDE is designed to work well with computers on the low end of the performance spectrum such as older resource-constrained machines.
All the versions of Ubuntu share the same packets and packet manager (apt-get), and they releases follow the main Ubuntu release (every 6 months). The release name is composed as year.month, so for example 12.10 is the release of October 2012.