study of chromium os
DESCRIPTION
TRANSCRIPT
Index Introduction........................................................................................................................................................ 4
FAQ ..................................................................................................................................................................... 5
Usage ................................................................................................................................................................... 7
SW Architecture ................................................................................................................................................. 9
Build Process .....................................................................................................................................................11
Portage Build System................................................................................................................................11
Prerequisites ............................................................................................................................................. 12
Setup Build Envrionment........................................................................................................................ 12
Build Chromium Browser ....................................................................................................................... 13
Init Setup........................................................................................................................................... 13
Get the Code ..................................................................................................................................... 13
Install Prerequisite Liraries ............................................................................................................ 13
Add debugging Messages ................................................................................................................ 13
Build Chromium OS ................................................................................................................................ 14
i> Initial Setup .................................................................................................................................. 14
ii> Get the Code................................................................................................................................ 14
iii> Create a chroot .......................................................................................................................... 15
iv> Enter the chroot ......................................................................................................................... 17
v> Set up board ................................................................................................................................ 18
vi> Enable a local user(guest) account (optioal) ........................................................................... 20
viii> Set the shared user password (optioal).................................................................................. 21
ix> Build packages ........................................................................................................................... 21
x> Build image.................................................................................................................................. 22
Start working on a package............................................................................................................. 26
Stop working on a package ............................................................................................................. 27
Autotest ............................................................................................................................................. 27
Chrome Web Apps ........................................................................................................................................... 29
Concepts.................................................................................................................................................... 29
Apps................................................................................................................................................... 29
Themes .............................................................................................................................................. 29
Extensions ......................................................................................................................................... 29
Installable Web Apps ............................................................................................................................... 29
Host Apps .......................................................................................................................................... 30
Packaged Apps ................................................................................................................................. 30
New Features .................................................................................................................................................... 31
Remote Desktop Capabilities - Chromoting .......................................................................................... 31
GPU Accelerated Compositing – WebGL .............................................................................................. 31
Reference .......................................................................................................................................................... 33
Google Chromium OS Main Site – http://www.chromium.org/ ............................................................. 33
Introduction.............................................................................................................................................. 33
FAQ ........................................................................................................................................................... 33
Usage ......................................................................................................................................................... 33
SW Architecture ....................................................................................................................................... 33
Build Process ............................................................................................................................................ 33
Debugging ................................................................................................................................................. 34
New Features ............................................................................................................................................ 34
Chrome Web App..................................................................................................................................... 34
Introduction Chromium OS is the open source development version of Google's Chrome OS. Chrome OS's source code
was released on November 19, 2009 under the BSD license as Chromium OS.
FAQ
Q1. The distinction between Google Chrome OS and Chromium OS.
Ans : Google Chrome OS is to Chromium OS what Google Chrome browser is to Chromium. Chromium OS
is the open source project, used primarily by developers, with code that is available for anyone to
checkout, modify and build their own version with.
Q2. Should I call my build Chromium OS or Google Chrome OS?
Ans : You should call it Chromium OS.
Q3. Will the autoupdate feature work on both Google Chrome OS and Chromium OS?
Ans : We don't plan to support autoupdate on Chromium OS, as we did not build the binaries, and we don't
know what modifications you've made to the system, so we don't want to blow away any changes you
may have made to the code. Therefore Google will not autoupdate Chromium OS systems, but you're
welcome to set up your own autoupdate server.
Google Chrome OS will autoupdate to keep consumer machines running the latest and greatest at all
times.
Q4. Will the verified boot feature work on both Google Chrome OS and Chromium OS?
Ans : The verified boot procedure relies on custom firmware and hardware modifications and hence will work
with only Google Chrome OS netbooks.
Q5. Where can I download Google Chrome OS?
Ans : Google Chrome OS is not a conventional operating system that you can download or buy on a disc and
install. As a consumer, the way you will get Google Chrome OS is by buying a netbook that has Google
Chrome OS installed by the OEM. Google Chrome OS is being developed to run on new machines that
are specially optimized for increased security and performance. We are working with manufacturers to
develop reference hardware for Google Chrome OS. These netbooks will be available in the fourth
quarter of 2010.
If you are the kind of developer who likes to build an open source operating system from scratch, you
can check out Chromium OS, build it and experiment with it. A number of sites have also posted
pre-built binaries of Chromium OS. However, these downloads are not verified by Google, therefore
please ensure you trust the site you are downloading these from.
Keep in mind that Chrome OS is not yet ready for general consumer use.
Q6. Is it true that you don't support hard disk drives (HDDs)?
Ans : Firstly, we should point out that the information in the open source release has been misinterpreted as
saying that we don't support local storage. We do, but we are asking our hardware partners for Google
Chrome OS to use solid state drives (SSDs) rather than hard disk drives (HDDs), for performance and
reliability reasons.
Secondly, this restriction doesn't apply to Chromium OS : It will work with conventional HDDs,
though the disk accesses are optimized for flash-based storage, like reduced read-ahead.
Clarification for Chromium OS (post on 2009/12/11)
1. This is not ready for consumers yet — everything you see can and probably will change by the time
Google Chrome OS-based devices are available late next year.
2. Please note that Google has not released an official binary for Chromium OS and therefore if you
download Chromium OS binaries please ensure that you trust the site you are downloading them from.
3. While we will try our best to help you through the Chromium discussion forums, we will not be officially
supporting any of these builds. Remember that you are downloading that specific site/developer's build of
Chromium OS.
Usage
1. I can't log in!!!
Ans : Login may fail under various circumstances. For example, if you do not have network connectivity
and you have never logged in before, then you will not be able to log in.
The login screen should display a message beneath the username/password input field. For example, if
you have network connectivity and provide the wrong credentials, you will be told that either your
username or password is incorrect.
To troubleshoot networking at this point, you have to jump to a virtual terminal (only enabled on dev
machines) by using Ctrl+Alt+F2 and entering the shared user password that you optionally set as part
of the build process. If you did not set this field, you will not be able to debug networking and
should plug into Ethernet at your earliest convenience.
If you are able to log in to the virtual terminal, reconfigure the networking service (sudo initctl restart
flimflam).
Note: If you are having trouble with wireless, just plug in an Ethernet cable. It is much easier to
troubleshoot a networking issue once you have logged in.
For more information about login errors, look at the log files:
* /var/log/libcros_log - logging related to chromium's interaction with system services
* /home/chronos/chrome_log - login manager (which is, actually, chrome) logs
2. I log in but the browser does not appear
Ans : If you do not have a black screen, try using the hotkey Ctrl+Alt+N to open a new window. If this
doesn't work, check slim.log to verify whether it's an error in slim, or in something else. The logs you
may be concerned about are:
* /var/log/messages
* /var/log/window_manager/chromoeos-wm.LATEST - for pre-login window manager logs
* /home/chronos/user/log/chromoeos-wm.LATEST - for post-login window manager logs
3. Wireless drops and does not reconnect
Ans : Drop into a terminal either through vt02 (Ctrl+Alt+F2) or Ctrl+Alt+T. Reconfiguring the connman
service may fix the problem.
4. What are the shortcut keys?
Ans : To get a visual overlay of shortcut keys available, hit F8 and then hold modifier keys like Ctrl, Alt, and
Shift to see the associated hotkeys.
Most browser shortcuts also apply :
http://www.google.com/support/chrome/bin/answer.py?hl=en&answer=95743
Are native applications supported?
Google Chrome OS is a web-centric system, so all applications are web applications; this provides powerful
and simple manageability and security. To write applications that will benefit from native code execution we
recommend using NativeClient, an open source project that allows web apps to run native code securely
within a browser. See http://code.google.com/p/nativeclient/ for more details.
Of course Chromium OS is open source, and it's Linux. This means that as a developer you can do pretty
much anything you want, including installing any Linux application.
Under Linux, web apps locate in "/opt/google/chrome/resources".
Action When Feature
F12 Running Toggle Window Overview mode.
It brings up a multi-window view, with the option to open additional browser
windows and switch between them.
F8 Running Toggle keyboard overlay showing all the shortcut keys and a command-line
interface that accepts common Linux commands.
Escape Window
Overview
Exit Window Overview mode.
F2 Boot Startup options - disable internal HDD to boot from USB stick
Ctrl + Alt + T Running Open a terminal window
Ctrl + Alt + L Running Lock the screen
Ctrl + Alt + M Running Enable external monitor
Ctrl + , Chrome Go to battery and network settings page
Ctrl + Tab Chrome Next Tab
Ctrl + Shift + Tab Chrome Prior Tab
Ctrl + 1 through
Ctrl + 8
Chrome Switches to the tab at the specified position number on the tab strip
Alt + Tab Running Next Window
Alt + Shift + Tab Running Prior Window
Close Lid Running Sleep mode
Power-Key Running Shutdown
Print Screen Running Take a screenshot and save it to
/home/chronos/user/Downloads/Screenshots/screenshot-YYYYMMDD-HH
MMSS.png
Ctrl-SPACE Running Select the previous input method
Shift-Alt Running Circle through the active input methods
SW Architecture Chromium OS consists of three major components :
* The Chromium-based browser and the window manager handling user interaction
* System-level software and user-land services : the kernel, drivers, connection manager, and so on
* Firmware
Chromium and the window manager
The window manager is responsible for handling the user's interaction with multiple client windows. It does
this in a manner similar to that of other X window managers, by controlling window placement, assigning the
input focus, and exposing hotkeys that exist outside the scope of a single browser window. Parts of the
ICCCM (Inter-Client Communication Conventions Manual) and EWHM (Extended Window Manager Hints)
specifications are used for communication between clients and the window manager where possible.
The window manager also uses the XComposite extension to redirect client windows to offscreen pixmaps so
that it can draw a final, composited image incorporating their contents itself. This lets windows be
transformed and blended together. The Clutter library is currently used to animate these windows and to
render them via OpenGL or OpenGL|ES.
System-level and user-land software
From here we bring in the Linux kernel, drivers, and user-land daemons. Our kernel is mostly stock except for
a handful of patches that we pull in to improve boot performance. On the user-land side of things we have
streamlined the init process so that we're only running services that are critical. All of the user-land services
are managed by Upstart. By using Upstart we are able to start services in parallel, re-spawn jobs that crash,
and defer services to make boot faster.
Here's a quick list of things that we depend on :
D-Bus – The browser uses D-Bus to interact with the rest of the system. Examples of this include the battery
meter and network picker.
Connection Manager – Provides a common API for interacting with the network devices, provides a DNS
proxy, and manages network services for 3G, wireless, and ethernet.
WPA Supplicant – Used to connect to wireless networks.
Autoupdate – Our autoupdate daemon silently installs new system images.
Power Management – (ACPI on Intel) Handles power management events like closing the lid or pushing the
power button.
xscreensaver – Handles screen locking when the machine is idle.
Standard Linux services – NTP, syslog, and cron.
Firmware
The firmware plays a key part to make booting the OS faster and more secure. To achieve this goal we are
removing unnecessary components and adding support for verifying each step in the boot process. We are also
adding support for system recovery into the firmware itself. We can avoid the complexity that's in most PC
firmware because we don't have to be backwards compatible with a large amount of legacy hardware. For
example, we don't have to probe for floppy drives.
Our firmware will implement the following functionality :
* System recovery – The recovery firmware can re-install Chromium OS in the event that the system has
become corrupt or compromised.
* Verified boot – Each time the system boots, Chromium OS verifies that the firmware, kernel, and system
image have not been tampered with or become corrupt. This process starts in the firmware.
* Fast boot – We have improved boot performance by removing a lot of complexity that is normally found in
PC firmware.
Build Process The computer to pratices steps in this document :
* Intel i7 CPU
* 3G RAM
* Ubuntu 10.04 Lucid 64-bit
Portage Build System
The Chromium project started to use Portage build system from Gentoo in Feb, 2010.
Portage is a package management system used by Gentoo, based on the concept of ports collections of
FreeBSD. Ports collections (or ports trees, or just ports) are the sets of makefiles and patches provided by
the BSD-based operating systems.
Each “port” listed here contains any patches necessary to make the original application source code compile.
Each port's Makefile automatically fetches the application source code, either from a local disk, CD-ROM or
via ftp, unpacks it on your system, applies the patches, and compiles. If all went well, a simple make install
will install the application and register it with the package system.
Precompiled (binary) ports are called packages. For most ports, a precompiled package also exists, saving
the user the work of having to compile anything at all. Each port contains a link to its corresponding package.
Gentoo Portage tree does not contain directories of Makefiles, but of so-called ebuilds, bash scripts that
describe separate functions to download, configure, make, install and remove a package and additional
functions that can be used to set up the operating environment for a package.
ebuilds are shell scripts with variables and functions which contain a description of the software, and
instructions on how to obtain, configure, compile, and install it, more closely akin to (but more powerful than)
the .spec files distributed in SRPMs.
Portage's main utility is emerge, which is written in Python and can be used by privileged users to easily
inspect and alter the set of installed packages on a Gentoo operating system.
emerge provides an interface to ebuild : managing an ebuild repository, resolving dependencies and similar
issues.
emerge calculates and manages dependencies, executes ebuilds and maintains the local Portage tree and
database of installed packages. The compilation settings used by ebuilds can be changed through the
CFLAGS environment variable, based on the specifications of the individual computer and on the user's
desire for optimization.
emerge and ebuild therefore have roughly the same relation as rpm has with yum, or dpkg has with APT.
The Portage system offers the use of "USE flags," which allows users to indicate which software features they
would like to include (and exclude) while building packages. The USE flags affect which dependencies are
required, generally affecting which optional features will be built into a given program when it is compiled.
For example, in packages which use a configure script, the USE flag feature would translate to :
./configure --with-feature
.
Prerequisites
You need to have Linux. We currently support the following :
* Ubuntu (Hardy 8.04 or newer, Lucid 10.04 recommended)
* A 64-bit system for performing the build
* An account with root access (needed to run chroot and modify the mount table)
* Chromium browser (binary or build it from source)
* Tools : repo, GIT (need git-core library)
Setup Build Envrionment
For those who use company’s network connecting to the internetwork, it should set the following environment
variable :
export GIT_PROXY_COMMAND=set-git-proxy.sh
export http_proxy=http://10.110.15.60:8080
, where “set-git-proxy.sh”’s contnet is as :
and the shell script file name, “set-git-proxy.sh”, could be changed as you wish.
#! /bin/bash
(echo "CONNECT $1:$2 HTTP/1.0"; echo; cat ) | socket 10.110.15.60 8080 | (read a; read a; cat )
Build Chromium Browser
Init Setup
Dowload and execute the script build/install-build-deps.sh (for Ubuntu) attempts to automate installing the
above software :
wget –r –l1 http://src.chromium.org/svn/trunk/src/build/install-build-deps.sh
On Lucid, it also need these fonts for layout tests :
sudo apt-get install ttf-indic-fonts
To build the Chromium OS version of Chromium with their build system, add “GYP_DEFINES” variable to
your environment :
export GYP_DEFINES="chromeos=1"
Get the Code
1. Download the source tarball :
http://chromium-browser-source.commondatastorage.googleapis.com/chromium_tarball.html
2. Untar the source tarball into the directory you've chosen.
For example : ~/chromium
3. Install the depot_tools :
3.1) Retrieve depot_tools; select one of these ways :
svn co http://src.chromium.org/svn/trunk/tools/depot_tools
3.2) Add depot_tools to your PATH :
For example, for the default bash shell, use:
export PATH=`pwd`/depot_tools:"$PATH"
4. Updating your checkout once by running
gclient sync --force
in the source code directory (~/chromium/src).
Install Prerequisite Liraries
Change to the “build” directory in Chromium browser source directory,
# cd chromium-browser/src/build
Execute “install-build-deps.sh” script.
Add debugging Messages
export GYP_DEFINES="chromeos=1 target_arch=ia32"
gclient runhooks --force
Build Chromium OS
cros_workon is a workflow tool for ChromiumOS development. It is currently in beta.
With cros_workon, developers subscribe to the packages they want to work on. The tools then only
checkout the packages a developer is subscribed to and only builds the packages a developer is
subscribed to.
When using cros_workon, gclient is no longer used, and two new commands are used instead:
repo
Usually run outside the chroot.
It's used to check out and sync your repositories and manage the tracking branches for git.
This is used instead of gclient.
If run inside the chroot, make sure you have "git config -l" configured with your correct email
address -- if not, you could lose local commits on repo sync.
src/scripts/cros_workon (will soon move be able to run cros_workon from anywhere in the
chroot)
Always run inside the chroot.
It's used to unmask a package ebuild so that
1) repo will be prepared to sync a local copy of the source, and
2) build_packages will use the local source instead of the stable version.
i> Initial Setup
Install “repo” through steps in : http://source.android.com/source/git-repo.html
For read-only access to the code :
export GITHOST:=http://src.chromium.org/git
ii> Get the Code
Execute commands :
$ mkdir mychromiumos
$ cd mychromiumos
$ repo init -u http://git.chromium.org/git/manifest -m minilayout.xml
#internal users use: repo init -u ssh://gitrw.chromium.org:9222/manifest-internal -m minilayout.xml
$ repo sync
“repo sync” done :
iii> Create a chroot
To simplify dependencies, development is done inside a chroot. The following command creates the chroot
for you.
$ cd src/scripts
$ ./make_chroot
or, faster :
$ cd src/scripts
$ ./make_chroot --fast
iv> Enter the chroot
To enter the chroot in order to do development, run the following command :
$ ./enter_chroot.sh
, or if you want to build your Chromium browser by the way, run the command as :
$ ./enter_chroot.sh --chrome_root=$(PATH/TO/CHROMIUM-BROWSER/SRC)
v> Set up board
You need to run setup_board in order to install the toolchain (gcc/glibc) for the target you wish to work on.
setup_board also creates the initial SYSROOT the target.
(chroot) $ ./setup_board --board=x86-generic –default --job 4
vi> Enable a local user(guest) account (optioal)
The local user account allows login with no password even if you can not connect to the Internet. If you are
customizing Chromium OS and having trouble logging in due to your customizations, it may be handy to be
able to bypass authentication and log yourself in as a test user. This is disabled by default for security reasons,
but if you want to enable it for a backdoor user USERNAME:
./enable_localaccount.sh USERNAME
Here, we use "guest" acctount :
./enable_localaccount.sh guest
viii> Set the shared user password (optioal)
The shared system level account ("chronos") password defaults to a long random string. If you want to be able
to sudo from the terminal in Chromium OS (this also includes actually installing the OS on your device), need
help debugging networking, or you have some other reason for needing to log on directly as the shared user,
you need to set up the password for the shared user:
./set_shared_user_password.sh
This will prompt you for a password. The encrypted password will be stored in ./shared_user_password.txt, so
you only need to do this once.
ix> Build packages
The ChromiumOS equivalent of "make".
(chroot) $ ./build_packages --board="x86-generic" --jobs=4
The number “8” means the number of cores of your CPU, you could change it to be available number.
By default, build_packages will build the stable version of a package (i.e. from committed git sources) unless
you are working on a package. If you are working on a package, build_packages will build using your local
sources.
In this phase, it spend around 9~10 hours…please be patient!!!
x> Build image
The ChromiumOS equivalent of "make install".
(chroot) $ ./build_image
If you want to use the developer server (./start_devserver in the chroot) and gmerge on the device to build and
merge changes that you make then you will need to disable the root filesystem signature checking. Give the
flag (which will auto complete) to build_image.
(chroot) $ ./build_image --noenable_rootfs_verification
The generated images are :
1> chromiumos_base_image.bin for Chromium OS.
2> chromiumos_image.bin for developer.
Start to build image :
Image built done :
Use Chromium OS Image through USB / VM
[VMware]
./image_to_vm.sh --from=../build/images/x86/Version.BuiltDate&Time –board=x86-generic
[USB]
./image_to_usb.sh --from=../build/images/x86/Version.BuiltDate&Time --to=/dev/USB-Node .
“USB-Node” should be like “/dev/sdc” other than “/dev/sdc1”
Start working on a package
In order to modify and build a local version of a package, you must first mark it active :
(chroot) $ ./cros_workon start <pkgname> # Use the name of the Portage package, e.g chromeos-wm
This marks the ebuild for the given package so that build_packages will use your local changes instead of the
stable, committed version.
If you don't know the package name, you can see all the available packages like this :
(chroot) $ ./cros_workon list --all
Special case : chromiumos-overlay is not in this list and cros_workon start/stop is not used. Follow the
instructions below under "Making and committing your changes".
Note :
cros_workon requires either a "--host" or "--board PLATFORM" option, to indicate the target that will be
affected by your local changes. Chances are that this argument is being silently provided by the contents of
src/scripts/.default_board.
If you need to work on package changes that should be built for multiple boards, you'll need to specify each
board with separate "start" commands. For that to work, you'll need to delete the .default_board file.
Stop working on a package
This tells the buildsystem to use stable pre-built version of the package. build_packages will now ignore your
local repository. Stopping doesn't delete your local copy, so don't be fooled into thinking it's still being used.
(chroot) $ ./cros_workon stop <pkgname>
Autotest
<Temporary Notice> Until the autotest is entirely converted, tested, and the new workflow is made default,
there are no stable ebuilds for anything autotest-related, in order to not mess with the original workflow. Until
that moment, the first thing that has to be done is to "workon" all autotest-related ebuilds. This also means that
there will be no prebuilt packages yet.
$ cros_workon start autotest autotest-tests
$ repo sync
[Running a test]
The operation of autotest is significantly different in cros-workon. Tests are organized in ebuilds, where each
ebuild implements certain number of tests. Tests consist of a build phase and run phase, where the first is
executed by the ebuild, and the second by the "run_remote_tests.sh" script, with exactly the same syntax as
before. Unlike before, tests have to be built with emerge-${board} before they can be ran using
run_remote_tests.sh.
Currently, tests are organized within these ebuilds :
chromeos-base/autotest-tests
To see which tests are implemented by an ebuild, run the usual pretended emerge:
$ emerge-${board} -pv autotest-tests
All tests have a default state, either enabled (+) or disabled (-). The TESTS= variable is a USE_EXPAND.
There are two ways to use these.
(1) Non-Incremental --- Simply override the list by a new list
TESTS="platform_MiniJailPidNamespace platform_MiniJailPtraceDisabled" emerge-${board} -pv
autotest-tests
(2) Incremental --- All USE_EXPAND flags are also accessible as USE flags, with the appropriate prefix,
and can be used incrementally with +, -
USE="tests_platform_MiniJailPidNamespace tests_platform_MiniJailPtraceDisabled" emerge-${board}
-pv autotest-tests
For operations across all tests, following incremental USE wildcard is supported by portage : "tests_*"
Both Incremental and Non-Incremental methods can be set/overriden by : the ebuild (default values),
make.conf, make.profile, /etc/portage, commandline.
Chrome Web Apps
Concepts
Apps
Contains installable web apps.
An installable web app can be a normal website with a bit of extra metadata; this type of app is called a
hosted app.
Alternatively, an installable web app can bundle all its content into an archive that users download when they
install the app; this is a packaged app.
Both hosted and packaged apps have icons in Google Chrome's New Tab page, and most users shouldn't be
able to tell the difference between them without looking at the address bar.
Before publishing a hosted app in the store, you must verify that you own the website that hosts the app's
content. Packaged apps might have some association with a website, but you have the option of designing
them so that they don't rely on the web at all.
Themes
Contains themes for Google Chrome, which change the way the browser looks.
Extensions
Contains Google Chrome Extensions, which change how the browser behaves and, in a limited way, how it
looks. Until the store is public, you can find extensions in the Extensions Gallery.
If your extension seems more like a website than a small browser add-on, consider making it a packaged app.
Packaged apps are implemented as extensions that have the additional ability to present an app-like interface.
[Terminology note : When this documentation talks about an app without giving any other details, it means
any of the above—an installable web app (either hosted or packaged), a theme, or an extension.]
Every app has a manifest, and most likely icons, that you put into a ZIP file and upload to the Chrome
Developer Dashboard. The Chrome Web Store takes the contents of this ZIP file and puts them in a
cryptographically signed .crx file. Users download this .crx file when they click the Install button for your
app.
To create installable web apps and extensions, you should be familiar with HTML, JavaScript, and CSS. If
you're targeting Google Chrome exclusively, you can depend on HTML5 and the other emerging APIs that
Google Chrome supports.
Installable Web Apps
An installable web app requires a .crx file that contains metadata describing the app. (The .crx file format is
just a variation of ZIP that's used by Google Chrome.) An app's .crx file can be hosted on your own server or,
more typically, by the Chrome Web Store.
The .crx file for an installable web app must contain a set of icons and a manifest that has details about how
the app should function. For a packaged app, the .crx file also contains any HTML, CSS, JavaScript, and
other files that the app needs.
Note : Unlike a packaged app, a hosted app has no access to the files inside its .crx file.
Host Apps
You just provide some icons and a manifest.
Packaged Apps
A packaged app is a web app that's bundled into a .crx file and can use Google Chrome Extension features.
You might want to use a packaged app if any of the following are true:
You don't want to run a service to host your app.
You want to build an app that works really well offline.
You want tighter integration with Google Chrome, using the extension APIs.
You build a packaged app just like you build an extension. All the resources that the app requires—HTML,
JavaScript, CSS, images, and any other files—go into the app's .crx file. The manifest is similar to a hosted
app's manifest, but it can include only local URLs, and you can add any field (such as "background_page")
that's available to extensions.
New Features
Remote Desktop Capabilities - Chromoting
One of the larger questions asked by novices to the Chrome OS experience is this: Can it run Windows apps?
Up until now, the answer has been a resolute, "no." Google’s Chrome operating system is entirely
Web-driven, in the sense that there’s nothing you can actually install into the operating system.
You access Web-driven applications via the browser and, though you can "install" or save these Web apps into
Chrome OS, you just can’t grab your average application CD, throw it in an optical drive, and expect
something magical to happen.
This feature would let users run "legacy PC applications" right in the browser, and that it would be
"something like" Microsoft's Remote Desktop Connection. This feature is probably closer to running an
application via Terminal Services or by first connecting to a host machine by using RDP or VNC.
For recent release of Chrome/Chromium(after 2010/06), uses can add “--enable-remoting” parameter after
Chromium/Chromium executable, “chrome --enable-remoting”，users can see there will show a option, “Set
Up Remoting…”, in Configuration.
Google wants everything run in browser!!!
GPU Accelerated Compositing – WebGL
WebGL is a cross-platform, royalty-free API used to create 3D graphics in a Web browser. Based on
OpenGL ES 2.0, WebGL uses the OpenGL shading language, GLSL, and offers the familiarity of the
standard OpenGL API. Because it runs in the HTML5 Canvas element, WebGL has full integration with all
Document Object Model (DOM) interfaces.
The canvas element is part of HTML5 and allows for dynamic, scriptable rendering of 2D shapes and
bitmap images. It is a low level, procedural model that updates a bit map and does not have a built in scene
graph.
Canvas consists of a drawable region defined in HTML code with height and width attributes. JavaScript
code may access the area through a full set of drawing functions similar to other common 2D APIs, thus
allowing for dynamically generated graphics.
Usage -
In HTML page :
In JavaScript code :
WebGL is a DOM API, which means that it can be used from any DOM-compatible language: JavaScript,
Java, or—if you embed WebKit into an application on a Mac—Objective C.
Major browser vendors Google (Chrome), Opera (Opera), Mozilla (Firefox), and Apple (Safari) are members
of the Khronos consortium's WebGL Working Group, along with many other 3D graphics developers.
WebGL Implementation
* Firefox
Supported in Firefox/4.0b1.
* Safari
Supported on Mac OS X 10.6 in the WebKit.
* Chrome/Chromium
Chromium must be launched from the command line in order to enable WebGL.
Linux : ./chrome --enable-webgl
Mac OS X : ./Chromium.app/Contents/MacOS/Chromium --enable-webgl
Windows : No command line options needed.
<canvas id="example" width="200" height="200">
This text is displayed if your browser does not support HTML5 Canvas.
</canvas>
var example = document.getElementById('example');
var context = example.getContext('2d');
context.fillStyle = "rgb(255,0,0)";
context.fillRect(30, 30, 50, 50);
Reference
Google Chromium OS Main Site – http://www.chromium.org/
Introduction
* Chromium OS wiki – http://en.wikipedia.org/wiki/Chromium_OS
FAQ
* The distinction between Google Chrome OS and Chromium OS –
http://blog.chromium.org/2009/12/whats-difference-between-chromium-os.html
* More detail answer – http://www.chromium.org/chromium-os/how-tos-and-troubleshooting/developer-faq
Usage
* Playing with Google Chromium OS –
http://garymlewis.com/instchg/2010/01/19/playing-with-google-chromium-os/
* Hexxen Linux instruction – http://chromeos.hexxeh.net/wiki/doku.php?id=linux_instructions
* More detail answer – http://www.chromium.org/chromium-os/how-tos-and-troubleshooting/developer-faq
* Chrome Apps – http://www.downloadsquad.com/2010/07/06/more-google-chrome-web-apps/
SW Architecture
* Chromium OS Design Document –
http://sites.google.com/a/chromium.org/dev/chromium-os/chromiumos-design-docs
Build Process
* HowTo & Troubleshooting – http://dev.chromium.org/chromium-os/how-tos-and-troubleshooting
* Build Chromium OS – http://sites.google.com/a/chromium.org/dev/chromium-os/building-chromium-os
* Linux Build Instructions Prerequisites –
http://code.google.com/p/chromium/wiki/LinuxBuildInstructionsPrerequisites
* Portage Build System –
http://en.wikipedia.org/wiki/Gentoo_Linux
http://en.wikipedia.org/wiki/Portage_(software)
* Portage Based Build – http://dev.chromium.org/chromium-os/building-chromium-os/portage-based-build
* Chromium changed to use Portage build system –
http://groups.google.com/a/chromium.org/group/chromium-os-dev/browse_frm/thread/337cca9a0da59ad6/
b91ccac986266a94?tvc=1#b91ccac986266a94
* FreeBSD Ports – http://www.freebsd.org/ports/
* Download Chrome – http://penkia.blogspot.com/2010/02/notes-on-chromium-os-for-arm.html
* Explanation in Traditional Chinese – http://wadefs.blogspot.com/2010/04/chromium-under-ubuntu-1.html
Debugging
* Debugging Tips – http://dev.chromium.org/chromium-os/how-tos-and-troubleshooting/debugging-tips
* Linux Debugging Tips – http://code.google.com/p/chromium/wiki/LinuxDebugging
New Features
Chromoting >
* Chromoting –
http://loda.hala01.com/2010/06/chrome-os-to-support-legacy-pc-apps-via-chromoting/
* How does Chromoting work? –
http://blog.kowalczyk.info/article/How-does-chromoting-works.html
*Chromoting Codes –
http://src.chromium.org/svn/trunk/src/remoting/
WebGL Support >
* WebGL Main Site –
http://www.khronos.org/webgl/
http://www.khronos.org/webgl/wiki/Main_Page
* WebGL Implementations –
http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation
* WebGL in Chrome –
http://www.khronos.org/developers/library/2010_siggraph_bof_webgl/WebGL-BOF-2-WebGL-in-Chrome_
SIGGRAPH-Jul29.pdf
* WebGL Testing Site –
http://www.chromium.org/developers/demos-gpu-acceleration-and-webgl
* WebGL (introduced in Chinese) –
http://heresy.spaces.live.com/blog/cns!E0070FB8ECF9015F!10277.entry?sa=769074931
* Canvas Tutorial –
https://developer.mozilla.org/en/Canvas_tutorial
* Canvas Usage –
http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html
Chrome Web App
1. http://code.google.com/intl/zh-TW/chrome/webstore/docs/index.html
2. http://code.google.com/intl/zh-TW/chrome/webstore/articles/apps_vs_extensions.html
3. http://code.google.com/intl/zh-TW/chrome/apps/docs/developers_guide.html
4. http://code.google.com/chrome/extensions/
http://code.google.com/chrome/extensions/overview.html
http://code.google.com/chrome/extensions/getstarted.html
http://code.google.com/chrome/extensions/devguide.html