Saturday, March 31, 2012

[Gd] New Player Options for Lists of Videos

| More

YouTube API Blog: New Player Options for Lists of Videos

Most developers know that the YouTube embedded player can display a single video, but did you know that it can be used to display a list of videos as well? There have been a number of recent enhancements around list playback functionality, and if you’re not already taking advantage of those new features, we wanted to let you know what you’re missing out on.

The first change of note is the syntax for embedding the player in an HTML document. As for single-video playback, you can use the <iframe> embed code to load a list of videos, and the IFrame embed supports HTML5 <video> playback in environments where Flash is not available.

Another exciting change relates to the lists of videos that you can load. The player is no longer limited to just displaying videos from an actual YouTube playlist. You can also load a user's uploaded videos, a user's favorite videos, or videos matching a specific search term. In the embed URL, the listType and list parameters control the list of videos that is loaded. The listType value can be either playlist (the default), user_uploads, or search. Depending on the listType value, the list parameter value should be set to the desired playlist id, YouTube user ID, or search term. For example, the following embed code displays the most recent videos uploaded in the “GoogleDevelopers” YouTube channel:

<iframe width="560" height="315" src="" frameborder="0" allowfullscreen></iframe>

The corresponding embedded player is shown below:

Finally, for developers who want more control over their player than what a simple embed code offers, a full YouTube JavaScript API is available for use. There are methods for loading lists, moving to the next/previous video in a list, and controlling whether playback is shuffled or looped. To give you an idea of how you can use this new JavaScript Player API functionality, we’ve put together a sample page that you can experiment with and use as inspiration when developing your own code.

—Jeff Posnick, YouTube API Team

[Gd] Minimum embeds: 200px x 200px

| More

YouTube API Blog: Minimum embeds: 200px x 200px

If you're a careful reader of the YouTube API Terms of Service as well as the YouTube Player documentation, you may have noticed that while embedded players smaller than the minimum size might not support all player features, we haven’t defined what that size is.

As a part of our spring cleaning, we've tidied up our documentation to specify a minimum player size, which is 200px by 200px.

This change will take effect beginning late April 2012, so please check your application to avoid surprises. If you have any questions or comments about this, or any other YouTube API feature, please let us know on the API forum.

-Jarek Wilkiewicz, YouTube API Team

[Gd] Congratulations to All Designers of Tipos Latinos 2012!

| More

Google Web Fonts: Congratulations to All Designers of Tipos Latinos 2012!

The Google Web Fonts team would like to extend our congratulations to all designers selected for the Tipos Latinos 2012 Biennial.

We were looking forward to seeing the results of this prestigious review of work by typeface designers across Latin America because we have been working with many of them.

Around a quarter of the typefaces featured are available in Google Web Fonts today – or very soon:

  • Buenard, by Gustavo J. Ibarra (Argentina)

  • Petrona, by Ringo Romei (Argentina)

  • Ruluko, by A. Sanfelippo, A. Díaz y M. Hernández (Argentina, Colombia, Colombia)

  • Unna, by Jorge de Buen (Mexico)

  • Acme, by Juan Pablo del Peral (Argentina)

  • Macondo, by John Vargas Beltrán (Colombia)

  • Rufina, by Martín Sommaruga (Uruguay)

  • Abril, by José Scaglione y Veronika Burian (Argentina)

  • Alegreya, by Juan Pablo del Peral (Argentina)

  • Almendra, by Ana Sanfelippo (Argentina)

  • Andada, by Carolina Giovagnoli (Argentina)

  • Bitter, by Sol Matas (Argentina)

  • Delius, by Natalia Raices (Argentina)

  • Rosarivo, by Pablo Ugerman (Argentina)

The Alegreya family (including its Small Caps sister family) received a "Mención de Excelencia" (Recognition of Excellence) – congratulations Juan Pablo!

You can read more about Tipos Latinos at

Posted by Dave Crossland, Font Consultant, Google Web Fonts

[Gd] Dev Channel Update

| More

Chrome Releases: Dev Channel Update

The Dev channel has been updated to 19.0.1084.1 for Windows, Mac, Linux and Chrome Frame.  This build contains following updates:

  • Fixed issue cannot add GMail app to Chrome. [Issue: 119975]
  • Fixed theme and bookmarks bar notifications. [Issue: 117027]
  • Fixed popup prompting permission for flash plugin. [Issue: 120358]

Full details about what changes are in this build are available in the SVN revision log. Interested in switching release channels? Find out how. If you find a new issue, please let us know by filing a bug.

Dharani Govindan
Google Chrome

[Gd] Stable Channel Update for Chromebooks

| More

Chrome Releases: Stable Channel Update for Chromebooks

The Stable channel has been updated to 18.0.1025.140 (Platform version: 1660.98.0) for Chromebooks (Acer AC700, Samsung Series 5, and Cr-48). Machines will be receiving updates to this version over the next several days.

Release highlights:

  • Read about improvements to Chrome 18
  • Improvements to wifi connectivity
  • Improvements to File Manager
  • Stability & security updates
  • Improvements to video playback from File Browser
  • Updates to Pepper Flash
  • 23036 - Caps lock is now triggered via the Shift + Search key combination (instead of the double Shift key combination).
  • Two finger click when resting/hovering thumb present fixed (users would see 3 finger clicks instead); Faulty 3 finger click turned off to correct this issue.
  • Shortcut key for submitting Feedback is set as Shift + Alt + i

Known issues:

  • 26151: Occasionally, some users experience loss of audio when playing long streaming videos. Rebooting the system restores audio.
  • 26731: When accessibility (verbal feedback) is enabled, viewing different pages causes the CPU usage to go to 100%. Restarting the machine resolves the issue temporarily. Workaround: Disable accessibility with audio feedback.

If you find new issues, please let us know by visiting our help site or filing a bug. Interested in switching to the Beta channel? Find out how. You can submit feedback using ‘Report an issue’ under the wrench menu.

Danielle Drew
Google Chrome

Friday, March 30, 2012

[Gd] Fridaygram: Mandela’s memory, Shuttle farewell, wine surprise

| More

Google Developers Blog: Fridaygram: Mandela’s memory, Shuttle farewell, wine surprise

Author Photo
By Scott Knaster, Google Developers Blog Editor

This week the Nelson Mandela Centre of Memory launched its online multimedia archive. This site features a large collection of documents, photos, and videos of and about Mandela, including private letters and diaries covering all periods of his life. The archive is built on Google App Engine and is supported by a grant from the Google Cultural Institute.

Last week we posted about an amazing ride-along video of the Space Shuttle Solid Rocket Booster. Now, as a coda to that, take a look at these words and photos from the Space Shuttle decommissioning process. In their retirement, the Shuttles will eventually go on public display, now that they have completed their service in space.

Finally, if you find yourself relaxing this weekend with a glass of wine, ponder for a moment how you could use that wine to turn ordinary metal into a superconductor. Then go ahead and drink up.

Once a week we post a Fridaygram, featuring cool stuff that has little to do with developer announcements. Each Fridaygram item must pass only one test: it has to be interesting to us nerds.

[Gd] Localize your apps and content more easily – new formats in Translator Toolkit

| More

Google Developers Blog: Localize your apps and content more easily – new formats in Translator Toolkit

By Chris Yang, Product Manager and Haidong Shao, Software Engineer, Translator Toolkit

Cross-posted with the Google Open Source Blog and the Google Translate Blog

At Google, we put a lot of energy into helping localize the world's information to make it more useful to more people. It's not just about localizing our own products – we want to provide tools that make it easy for translators and developers around the world to localize their own apps and content. Google Translator Toolkit is our online translation tool for amateur and professional translators -- it’s built on Google Translate and supports more than 100,000 language pairs.

This week, the Translator Toolkit team has launched support for four new translation-related file formats:

Android Resource (.xml)
Application Resource Bundle (.arb)
Chrome Extension (.json)
GNU gettext-based (.po)

With these new file formats, you can use Translator Toolkit to localize your apps and other products and content much more quickly and easily.

For example, to translate your Android application, go into the res/values directory and upload strings.xml into Translator Toolkit -- Translator Toolkit will now automatically translate it. You can then share your translations with amateur or professional translators, who can localize the text using Translator Toolkit’s WYSIWYG online editor.

When you’re finished, you can export your translated application and store it in a locale-specific directory in Android. Voilà -- easy localization! 翻译起来太方便了!

In addition, we’ve made the Translator Toolkit interface more intuitive for these new file formats so users can translate faster and more accurately. For example, you can turn on ‘Customized colors’ so translators can annotate the edited segments, ‘Number of characters in the segment’ to make sure the text doesn’t run too long (very important for mobile devices), and ‘Synchronized scrolling’ so you can scroll the original and translated text at the same time, which makes navigation much easier.

With these new file formats and UI features, along with the file formats we already support (.aea, .srt, .html), we hope Translator Toolkit can help you reach more users around the world.

When you’re ready, give Google Translator Toolkit a try and suggest any improvements you’d like to see so we can work on making it even better.

Chris Yang and Haidong Shao are on the Google Translation Toolkit team.

Posted by Scott Knaster, Editor

[Gd] CSS: fast to load, easy to maintain

| More

Google Developers Blog: CSS: fast to load, easy to maintain

By Matt Atterbury and Joshua Marantz, Pagespeed Automatic Team

Fast web pages are important, but so are maintainable ones. For example, CSS @import helps web designers modularize the implementation of their sites. The drawback to using @import is performance. Each @import is a new HTTP request, and every level of @import costs an additional serial round-trip between browser and server, since the browser does not know the URI of the imported CSS file until it downloads, parses, and executes the file that’s importing it. Here’s a waterfall diagram of a simple HTML page that uses @import to load a CSS file that includes a background image:

Web designers deserve the same benefits enjoyed by programmers, who get to use optimizing compilers and other tools to employ modularity without sacrificing performance. Driving toward this goal, we recently announced mod_pagespeed, which supports the new feature flatten_css_imports.

Using this feature, the same web page is automatically optimized by flattening the imported CSS files into their parent. This reduces the number of HTTP requests, and more importantly, the number of serial round trips. In this case, the small background image also got inlined into the combined CSS file, reducing the serial round-trip count by 2:

This feature is especially useful to WordPress users with child themes that override their parent theme ( because that feature uses @imports. But every web page and web user benefits from CSS that’s fast and well-structured, so if you’re an Apache administrator, download mod_pagespeed today and read more on our code site.

Matt Atterbury and Joshua Marantz are Software Engineers on Google’s Pagespeed Automatic team in Cambridge, MA, which is dedicated to making the web faster for everyone. When not coding, Matt is probably on his bike. Josh has been working on making software run fast for several decades, at Google and before that on accelerated chip simulation.

Posted by Scott Knaster, Editor


[Gd] OAuth 2.0 Playground: new features

| More

Google Developers Blog: OAuth 2.0 Playground: new features

Author PhotoBy Nicolas Garnier, Developer Relations

Last November, we launched the OAuth 2.0 Playground, a tool enabling you to easily experiment with the OAuth 2.0 protocol and APIs that use the protocol.

screen shot
The OAuth 2.0 Playground

Since then, we've continued adding new features to improve the developer experience and increase the versatility of the tool.

Below is a list of features that we added since the initial release of the OAuth 2.0 playground.

Support for the OAuth 2.0 Client-side flow

You can now use the playground to experiment with the OAuth 2.0 Client-side flow by simply changing a setting in the OAuth 2.0 configuration dialog. Once set, every subsequent authorization request is performed using the client-side flow, and the playground’s interface and logic adapt accordingly.

screen shot
Setting the OAuth flow type

Support for newer OAuth 2.0 drafts

We have added a setting to change the location of the access token in authorized requests to the APIs. We added support for the authorization header with a Bearer prefix and the access_token URL parameter locations. This makes the playground compatible with most APIs supporting OAuth 2.0 drafts 10 to 25.

screen shot
Setting the access token location

Display available API operations

You can now easily display all the operations that are available using your current access token. After clicking the Find available Request URIs button, the operations along with their associated HTTP Methods and URIs are displayed on the right-hand side. This should help you quickly set up your request to the Google APIs without needing to search through the online documentation.

screen shot
Displaying the available endpoints after being authorized for the Google+ API

Note: the technique used to find the list of operations available given an access token is described in this blog post.

Support for the access_type and the approval_prompt parameters

The playground now also lets you try the new Google-specific settings of the OAuth 2.0 flow: the access_type and the approval_prompt parameters of the authorization request.

screen shot
Setting the access type and whether or not to force the approval prompt

Automatically refresh access tokens

If a refresh token is available, you can enable a feature that will automatically refresh the access token shortly before it expires. This is convenient if you are using the playground for a long time or if you are re-initializing the playground using the deep-link feature.

screen shot
Enabling the access token auto-refresh feature

Selectable links in responses

Clicking any links in an HTTP response will populate the request URI field so that you can quickly and conveniently set up the playground for the next operation.

screen shot
Clicking a link populates the Request URI field

If you have any feedback or would like to get in touch with us, please don’t hesitate to post on the OAuth 2.0 Playground forum.

Nicolas Garnier joined Google Developer Relations in 2008 and lives in Zurich. He is a Developer Advocate focusing on Google Apps and Web APIs. Before joining Google, Nicolas worked at Airbus and at the French Space Agency where he built web applications for scientific researchers.

Posted by Scott Knaster, Editor

[Gd] Moving the Google+ Hangouts API out of preview

| More

Google Developers Blog: Moving the Google+ Hangouts API out of preview

By Amit Fulay, Product Manager, Google+ Hangouts

Cross-posted from the Google+ Developers Blog

One of the most important ways we connect with others is in person. That's why we're so excited about Google+ Hangouts, and why we launched a preview of the Hangouts API a few months ago. Today we're moving this API out of preview, and enabling developers to launch and share their hangout apps with the entire Google+ community!

Hangout apps are regular web apps, running in a big window inside the Hangout UI. In addition to using shared-state APIs to give users real-time interactivity, you also have access to built-in Hangout features, such as:
  • Initiate a group video chat with up to 10 people 
  • Control hangout microphones, cameras, speakers and volume levels 
  • Add sound effects and attach image overlays to faces 
  • Set UI elements such as the video feed, chat pane, and notifications
It’s easy to get started: read the documentation, build and publish your app, and then let users know. You can easily get the word out in one of two ways: 1) post a link to it on Google+, and/or 2) add the new hangout button to your website. In either case, anyone who clicks will start a new hangout with your app running inside. It then appears in the “Recent” apps pane for future hangouts.

To get the ball rolling, we're introducing a new "Apps" pane in Google+ Hangouts, as well as some featured applications, including Aces HangoutCacoo, Scoot & Doodle, Slideshare, Clubhouse Challenge by Bravo, and Google Effects. We’re looking forward to seeing what you can dream up in the weeks and months ahead.

Follow the conversation on Google+, and happy building!

Amit Fulay is Product Manager for Google+ Hangouts.

Posted by Scott Knaster, Editor

[Gd] The Go project reaches a major milestone: Go 1

| More

Google Developers Blog: The Go project reaches a major milestone: Go 1

By the Go team

the Go Gopher

In November 2009 Google announced the Go project, a new open source programming language. Since then more than 200 outside contributors have made thousands of contributions to the code, tests, and documentation. The open source community has been essential to Go's success.

It is a great pleasure to announce today that the Go project has reached a stable point we are calling Go version 1, or Go 1 for short. Go 1 is the result of months of work refining the specification, improving the implementation, increasing portability and re-working and adjusting the standard library. Go 1 offers compatibility for future growth: programs written to the Go 1 specification will work dependably for years to come even as Go continues to develop.

The benefits of Go 1 are also available to Google App Engine developers, as Go 1 is now the standard Go runtime on Google App Engine.

Go 1 is a consistent, portable, dependable base upon which to build programs, projects, and businesses. To learn more about Go 1, hear what the gophers have to say at the Go blog. For more information about Go in general, visit, which has documentation, references, articles, and even an interactive tour of the language.

When he's not traveling the world, the Go Gopher lives in Paris with his collection of medals won at international staring competitions. He enjoys "The Wire" and any movies by Werner Herzog.

Posted by Scott Knaster, Editor

[Gd] A First Attempt at Apps Script with Spreadsheets

| More

Google Apps Developer Blog: A First Attempt at Apps Script with Spreadsheets

The Apps Script team held a hackathon in Washington DC on March 7. Over 80 developers attended and we had some great demos at the end of the evening. One of the demos was from Rusty Mellinger, who explains his script in this blog post. If you missed the DC hackathon, sign up for our next one in Chicago on April 19. -Jan Kleinert

I was lucky enough to attend Google’s Apps Script Hackathon at their office in DC, recently, and got a chance to play with Apps Script. After a quick walk-through tutorial, Jan gave us a couple of hours to hack around with it.

Scripts in Apps Script are written in JavaScript and stored, edited, and run on Google's servers, interfacing with a big list of included services. You can call the scripts from spreadsheets, Google Sites, or from hits to a generated URL.

Roommate Payment Spreadsheet

My roommates and I keep a spreadsheet on Google Docs to track who owes what, but since we’re a house full of software engineers, it’s gotten pretty complicated. Each row records the details of a single transaction: who paid, the total, and what percentages of the payment are on behalf of which roommates. All these interpersonal debts are added up into the (J5:M8) matrix, cancelled out across the diagonal into (P5:S8) to get a single debt for each roommate pairing, and then those are totalled into the final "Shake Out", (F4:F7), which says whether you owe or are owed. Maybe Apps Script could make my life simpler here?

Automatic Emails

First, I’m currently owed a fair amount of money, so I set up automated reminder emails to the roommates who are behind:

// Send emails to everybody with their current status.
function emailDebtors() {
var ss = SpreadsheetApp.getActiveSpreadsheet();
var results = ss.getRange( "G4:G7" ).getValues();
var emails = ss.getRange( "O3:R3" ).getValues();
var numUsers = 4;

for(var i = 0; i != numUsers; i++) {
var val = Math.round(results[i][0]);

if (val > 0) {
// This guy owes money in the shake-out.
emails[0][i], "You're a deadbeat!",
"You owe $" + val + ". Please pay it!");

This just pulls the current totals from the (G4:G7) "Shake Out", as well as their respective email addresses from (O3:R3). When this function is called, if any of them owe more than $0, they get a friendly reminder!

Custom Menus

I could set that up to trigger daily or weekly, but it only really needs to happen when somebody needs to collect what they’re owed, so I’ve added it as an option to the sheet’s menu on start-up.

function onOpen() {
var ss = SpreadsheetApp.getActiveSpreadsheet();
var menuEntries = [ { name: "Email debtors",
functionName: "emailDebtors"}];
ss.addMenu( "SkyCastle", menuEntries );

Easy! Now when somebody wants to collect, they just click the “SkyCastle -> Email debtors” option and the appropriate reminder emails are sent out, from their own Gmail address.

Historical Charting

I still had a couple of hours, and wanted to play with the UI and Google Charts services, so I decided to chart the “Shake Out” values over the history of the spreadsheet. The existing cells are hard-coded to operate on the total sums from the full sheet, so I had to re-implement the math to track it line-by-line. (This isn’t all bad, because I can use it to double check the existing arithmetic, which was sorely needed.)

The basic sketch is as follows:

var data = Charts.newDataTable()
.addColumn(Charts.ColumnType.NUMBER, "Row");
for (var i = 0; i != 4; i++) {
data.addColumn(Charts.ColumnType.NUMBER, names[i]);

for (var i = 0; i != NUMROWS; i++) {
var row = Array(5);
// …
// Process the current line here, and compute the shake-out.
// …

I’ve omitted the actual calculation, because it’s just a bunch of hacks specific to our spreadsheet formulas. Each row contains the row number, and the accumulated shake-out thus far, and gets added to the `data` table. I break out of the loop once I go off the end of my data and start hitting `NaNs`.

To create the line chart and add it to a new UI window:

var chart = Charts.newLineChart()
.setDimensions(700, 400)
.setTitle("Debt History")

var uiApp = UiApp.createApplication()
.setTitle("Payment History");
return uiApp;

After adding this function as another option in our custom `SkyCastle` menu and clicking it, we see a nice graph. (I’m almost always on the bottom, but that’s because I make the actual rent and utility payments.) The final entries are equal to the original "Shake Out" cells, so our old arithmetic seems correct, too.

Lessons Learned

The built-in debugger isn’t bad; use the `Select function` dropdown and click the bug icon. I also used Logger.log() liberally while trying to get things working right. (Go to `View -> Logs` in the Script Editor to view that output.)

Apps Script seems to work well, overall, and hooks into a nice and expanding array of Google products and data sources. The GWT-backed UI service is a clever idea, though I barely had a chance to touch it.

Thanks again to Jan and Google for hosting this Hackathon; I can’t wait for the next one!

Rusty Mellinger

Rusty Mellinger co-founded Illogic Inc, making heavy use of Google Apps and GWT.


[Gd] Making PATCH requests from App Engine

| More

Google Apps Developer Blog: Making PATCH requests from App Engine

PATCH requests allow you to perform partial updates on many of our REST APIs and in most cases can save bandwidth.

If you have ever tried to do a PATCH request on an App Engine application, you probably realized that it is not possible and that the list of HTTP Methods allowed is whitelisted to the following methods only: GET, POST, HEAD, PUT and DELETE. Trying to perform a PATCH request raises the following Exception: PATCH is not one of the supported http methods: [GET, POST, HEAD, PUT, DELETE]

There is a workaround to this. Most of our APIs support the X-HTTP-Method-Override header. This header can be used in a POST request to “fake” other HTTP methods. Simply set the value of the X-HTTP-Method-Override header to the HTTP method you would like to actually perform.

For example, to make a PATCH request to the Google Tasks API to update only the Notes field of a particular task you could use the following HTTP request:

POST /tasks/v1/lists/@default/tasks/TASK_ID HTTP/1.1
X-HTTP-Method-Override: PATCH
Authorization: Bearer
Content-Type: application/json
Content-Length: 31

{“Notes” : “Patch is working!”}

Which would be equivalent to this HTTP Request, which is not supported on App Engine:

PATCH /tasks/v1/lists/@default/tasks/TASK_ID HTTP/1.1
Authorization: Bearer
Content-Type: application/json
Content-Length: 31

{“Notes” : “Patch is working!”}

For instance, in an App Engine Java environment you could construct and execute this request this way:

URL url = new URL("" +     
"lists/@default/tasks/" + TASK_ID);
HTTPRequest request = new HTTPRequest(url, HTTPMethod.POST);
request.addHeader(new HTTPHeader("X-HTTP-Method-Override", "PATCH"));
request.addHeader(new HTTPHeader("Authorization", "Bearer " +
request.setPayload("{\"Notes\" : \"Patch is working!\"}".getBytes());

URLFetchService fetchService = URLFetchServiceFactory.getURLFetchService();
HTTPResponse response = fetchService.fetch(request);

This trick can also be used if your application server is behind a firewall, behind a proxy server or in any other environment where HTTP methods other than POST might not be allowed. In that case you could use the X-HTTP-Method-Override header the same way to workaround these limitations.

You may also use our Google APIs Client library for Java or our Google APIs Client library for Python, both of which have support for PATCH requests and use the X-HTTP-Method-Override header when appropriate.

Nicolas Garnier profile | twitter | events

Nicolas joined Google’s Developer Relations in 2008. Since then he's worked on commerce oriented products such as Google Checkout and Google Base. Currently, he is working on Google Apps with a focus on the Google Calendar API, the Google Contacts API, and the Tasks API. Before joining Google, Nicolas worked at Airbus and at the French Space Agency where he built web applications for scientific researchers.


Thursday, March 29, 2012

[Gd] Announcing App Engine Research Awards

| More

Google App Engine Blog: Announcing App Engine Research Awards

One of the most rewarding things about working on App Engine is watching our customers use the platform in new and unexpected ways. We're lucky to have a front row seat to the growth and success of so many innovative new projects, and in that spirit, we are pleased to announce the Google App Engine Research Awards.

This new awards program will support 15 projects by providing App Engine credits in the amount of $60,000 to each project for one year, additional Google services such as Google Cloud Storage will be coming soon as part of the program.

We are committed to supporting scientific and academic research and welcome university faculty from all fields to participate.  Award projects may focus on activities such as social or economic experiments, developing academic aids, analysis of gene sequence data, or using App Engine MapReduce in ways we hadn’t even considered!  If your research has the potential to advance discovery, generates heavy data loads or is in need of an easy-to-use, easy-to-scale platform, we encourage you to submit your proposal.

You can find details on how to apply on our Google Research website. Applications will be accepted until 11:59 p.m. PST, May 11, 2012.

- Posted by the App Engine Team

[Gd] Making the Android Developer Console work for your whole team

| More

Android Developers Blog: Making the Android Developer Console work for your whole team

[This post is by Ellie Powers, a product manager on the Google Play team. — Tim Bray]

As your apps have gotten more successful, more people have joined your team. Today, we’re making it easier to work together on analyzing and managing your published Android apps. Sharing passwords is generally a bad idea; so as of now, there’s no need to do that for the Android Developer Console — everyone can use his or her own Google account.

The account that you use today to sign into the Android Developer Console will become the account owner; only the account owner can manage access to the Console. The account owner can email an invitation to anyone; when they accept it, they’ll need to use a Google account to sign in.

Different people in your team do different jobs, so when you invite someone to your Android Developer Console, you’ll be able to specify what access they need. Today, you can limit access per-user to financial reports. In the future, we’ll give you more fine-grained control over access to the Console. For details, see Account owner and user access.

We hope this helps your team collaborate more easily. If you have any issues, feel free to get in touch via the Developer Help Center.

Join the discussion on

+Android Developers


[Gd] Moar better graphics

| More

Chromium Blog: Moar better graphics

The latest Stable channel release of Chrome brings improvements to both Canvas2D’s speed and WebGL’s reach.

We’ve enabled GPU-accelerated Canvas2D on capable Windows and Mac computers, which should make web applications like games perform even better than a pure software implementation. GPU-accelerated Canvas2D has previously been enabled in the Beta channel for quite some time, so hopefully developers have had a chance to try it out. We’re continuing to make improvements and tweaks to our Canvas2D implementation, so please file a bug in our public issue tracker if you encounter problems.

WebGL enables compelling 3D content on the web, so we want to ensure that as many users as possible have access to this technology. That’s why we’ve enabled SwiftShader, a software rasterizer licensed from our friends at TransGaming, for users with older configurations. Keep in mind that a software-backed WebGL implementation is never going to perform as well as one running on a real GPU, but now more users will have access to basic 3D content on the web. See our previous blog post for more details on SwiftShader and how to try it out.

Posted by John "More CPU in Your GPU" Bauman and Brian "FPS" Salomon

Wednesday, March 28, 2012

[Gd] Dev Channel Update

| More

Chrome Releases: Dev Channel Update

The Dev channel has been updated to 19.0.1081.2 for Windows, Mac, Linux and Chrome Frame.  This build contains following updates:

  • Updated V8 -
  • The Other Devices menu on the new tab page restores the navigation history when a tab is restored.
  • [Windows] Disable file: or data: downloads for security hardening.
  • [Mac] Fixed:  Extension and download icons are drawn incorrectly (Issue: 118755)

Full details about what changes are in this build are available in the SVN revision log. Interested in switching release channels? Find out how. If you find a new issue, please let us know by filing a bug.

Dharani Govindan
Google Chrome

[Gd] Stable Channel Release and Beta Channel Update

| More

Chrome Releases: Stable Channel Release and Beta Channel Update

The Chrome team is excited to announce the release of Chrome 18 to the Stable Channel for Windows, Mac, Linux and Chrome Frame. 18.0.1025.142 contains a number of new features including faster and fancier graphics. More detailed updates are available on the Chrome Blog and the Chromium Blog.  

Security fixes and rewards:
Please see the Chromium security page for more detail. Note that the referenced bugs may be kept private until a majority of our users are up to date with the fix.

Some of the items listed below represent the start of hardening measures based on study of the exploits submitted to the Pwnium competition.

  • [$500] [109574] Medium CVE-2011-3058: Bad interaction possibly leading to XSS in EUC-JP. Credit to Masato Kinugawa.
  • [$500] [112317] Medium CVE-2011-3059: Out-of-bounds read in SVG text handling. Credit to Arthur Gerkis.
  • [$500] [114056] Medium CVE-2011-3060: Out-of-bounds read in text fragment handling. Credit to miaubiz.
  • [116398] Medium CVE-2011-3061: SPDY proxy certificate checking error. Credit to Leonidas Kontothanassis of Google.
  • [116524] High CVE-2011-3062: Off-by-one in OpenType Sanitizer. Credit to Mateusz Jurczyk of the Google Security Team.
  • [117417] Low CVE-2011-3063: Validate navigation requests from the renderer more carefully. Credit to kuzzcc, Sergey Glazunov, PinkiePie and scarybeasts (Google Chrome Security Team).
  • [$1000] [117471] High CVE-2011-3064: Use-after-free in SVG clipping. Credit to Atte Kettunen of OUSPG.
  • [$1000] [117588] High CVE-2011-3065: Memory corruption in Skia. Credit to Omair.
  • [$500] [117794] Medium CVE-2011-3057: Invalid read in v8. Credit to Christian Holler.

The bugs [112317], [114056] and [117471] were detected using AddressSanitizer.

We’d also like to thank miaubiz, Chamal de Silva, Atte Kettunen of OUSPG, Aki Helin of OUSPG and Arthur Gerkis for working with us during the development cycle and preventing security regressions from ever reaching the stable channel. $8000 of additional rewards were issued for this awesomeness.

This version also contains the new Adobe Flash release, see release notes. Full details about what changes are in this release are available in the SVN revision log.  Interested in hopping on the stable channel?  Find out how.  If you find a new issue, please let us know by filing a bug.

Karen Grunberg
Google Chrome

[Gd] Go Version 1 now on App Engine

| More

Google App Engine Blog: Go Version 1 now on App Engine

Today, with the release of Go 1, a stable version of the Go language, libraries and tools, we're releasing a new Google App Engine SDK for the Go runtime.

Go is a statically typed, compiled language with a dynamic and lightweight feel. With Go you get the efficiency benefits of being close to the machine–your programs compile to native code–with the productivity and quick turnaround of a scripting language. Go apps are easy to write, start fast, and run fast. There has never been a better way to build scalable high-performance cloud applications.

The Go runtime provides clean, idiomatic Go APIs for the popular App Engine services (Blobstore, Datastore, Memcache, and so on) and a straightforward development process. As with the Python and Java SDKs, Go apps can be tested locally with the development server and, most convenient, the development server automatically compiles your Go code, so to test a change all you need to do is to refresh your browser.

The Go 1 SDK also brings improvements and bug fixes. It uses the new Go 1 time API throughout the SDK, provides a MultiError type for error handling in batch operations, and  supports Datastore Cursors and the XMPP and Log services. See the release notes for the details.

Although the Go App Engine runtime is still in experimental status for now, the language stability offered by Go 1 is a major milestone. To learn more about Go 1, see the announcement post at the Go blog and the wealth of documentation at

- Posted by the Go and App Engine Teams